@Test(dependsOnMethods = {"testDeployApplication", "testLocatedLocation"})
  public void testDeployApplicationFromBuilder() throws Exception {
    ApplicationSpec spec =
        ApplicationSpec.builder()
            .type(RestMockAppBuilder.class.getCanonicalName())
            .name("simple-app-builder")
            .locations(ImmutableSet.of("localhost"))
            .build();

    ClientResponse response = clientDeploy(spec);
    assertTrue(response.getStatus() / 100 == 2, "response is " + response);

    // Expect app to be running
    URI appUri = response.getLocation();
    waitForApplicationToBeRunning(response.getLocation(), Duration.TEN_SECONDS);
    assertEquals(
        client().resource(appUri).get(ApplicationSummary.class).getSpec().getName(),
        "simple-app-builder");

    // Expect app to have the child-entity
    Set<EntitySummary> entities =
        client()
            .resource(appUri.toString() + "/entities")
            .get(new GenericType<Set<EntitySummary>>() {});
    assertEquals(entities.size(), 1);
    assertEquals(Iterables.getOnlyElement(entities).getName(), "child1");
    assertEquals(
        Iterables.getOnlyElement(entities).getType(),
        RestMockSimpleEntity.class.getCanonicalName());
  }
  @Override
  public ListenableFuture<RpcResult<Void>> startListening() {

    ClientResponse response = null;
    try {
      response = extractWebSocketUriFromRpc(this.streamInfo.getIdentifier());
    } catch (ExecutionException e) {
      logger.trace("Execution exception while extracting stream name {}", e);
      throw new IllegalStateException(e);
    } catch (InterruptedException e) {
      logger.trace("InterruptedException while extracting stream name {}", e);
      throw new IllegalStateException(e);
    } catch (UnsupportedEncodingException e) {
      logger.trace("UnsupportedEncodingException while extracting stream name {}", e);
      throw new IllegalStateException(e);
    }
    boolean success = true;
    if (response.getStatus() != STATUS_OK) {
      success = false;
    }

    final RestRpcResult rpcResult = new RestRpcResult(success, response.getLocation());
    createWebsocketClient(response.getLocation());

    ListenableFuture<RpcResult<Void>> future =
        pool.submit(
            new Callable<RpcResult<Void>>() {
              @Override
              public RpcResult<Void> call() {
                return rpcResult;
              }
            });

    return future;
  }
  @SuppressWarnings("deprecation")
  @Test
  public void testReferenceCatalogEntity() throws Exception {
    getManagementContext().getCatalog().addItem(BasicEntity.class);

    String yaml =
        "{ name: simple-app-yaml, location: localhost, services: [ { serviceType: "
            + BasicEntity.class.getName()
            + " } ] }";

    ClientResponse response =
        client()
            .resource("/v1/applications")
            .entity(yaml, "application/x-yaml")
            .post(ClientResponse.class);
    assertTrue(response.getStatus() / 100 == 2, "response is " + response);

    // Expect app to be running
    URI appUri = response.getLocation();
    waitForApplicationToBeRunning(response.getLocation());
    assertEquals(
        client().resource(appUri).get(ApplicationSummary.class).getSpec().getName(),
        "simple-app-yaml");

    ClientResponse response2 = client().resource(appUri.getPath()).delete(ClientResponse.class);
    assertEquals(response2.getStatus(), Response.Status.ACCEPTED.getStatusCode());
  }
 protected T get(URI uri) {
   ClientResponse response =
       ClientUtil.readEntity(
           uri, getHttpClient(), getResourceRepresentationType(), ClientResponse.class);
   if (logger.isDebugEnabled()) {
     logger.debug("Request Accept header: " + getResourceRepresentationType());
     logger.debug("Response header: " + response.getType());
   }
   final int status = response.getStatus();
   if (followRedirectionEnabled
       && status == ClientResponse.Status.MOVED_PERMANENTLY.getStatusCode()) {
     final URI location = response.getLocation();
     if (location != null) {
       this.thisResourceUri = location;
       this.absoluteThisResourceUri = generateAbsoluteUri();
       return get();
     }
   }
   if (followRedirectionEnabled
       && (status == ClientResponse.Status.FOUND.getStatusCode()
           || status == ClientResponse.Status.SEE_OTHER.getStatusCode())) {
     final URI location = response.getLocation();
     if (location != null) {
       URI absolutionLocation = getHttpClient().getAbsoluteUri(location, getReferrerUri());
       return get(absolutionLocation);
     }
   }
   if (status < 300 || (status == ClientResponse.Status.NOT_MODIFIED.getStatusCode())) {
     if (response.hasEntity()
         && response.getStatus() != ClientResponse.Status.NO_CONTENT.getStatusCode()) {
       lastReadStateOfEntity = response.getEntity(getEntityClass());
       if (getClientUtil() != null) {
         try {
           getClientUtil().parseLinks(lastReadStateOfEntity, getRelatedResourceUris());
         } catch (Exception ex) {
           logger.warn(ex.getMessage(), ex);
         }
       }
       if (invokeGet) {
         invokeGETOnNestedResources();
       }
     } else {
       lastReadStateOfEntity = null;
     }
     getInvocationCount++;
     Map<String, Object> headers = new HashMap<String, Object>();
     EntityTag tag = response.getEntityTag();
     if (tag != null) {
       headers.put(HttpHeaders.ETAG, tag);
     }
     Date date = response.getLastModified();
     if (date != null) {
       headers.put(HttpHeaders.LAST_MODIFIED, date);
     }
     cachedHeaders.put(uri.toString(), headers);
     return lastReadStateOfEntity;
   }
   throw new UniformInterfaceException(response);
 }
  @Test
  public void testDeployApplication() throws Exception {
    ClientResponse response = clientDeploy(simpleSpec);

    HttpTestUtils.assertHealthyStatusCode(response.getStatus());
    assertEquals(getManagementContext().getApplications().size(), 1);
    assertRegexMatches(response.getLocation().getPath(), "/v1/applications/.*");
    // Object taskO = response.getEntity(Object.class);
    TaskSummary task = response.getEntity(TaskSummary.class);
    log.info("deployed, got " + task);
    assertEquals(
        task.getEntityId(),
        getManagementContext().getApplications().iterator().next().getApplicationId());

    waitForApplicationToBeRunning(response.getLocation());
  }
Пример #6
0
  // @Test
  public void testSubnetCascadingDelete() {
    // Create a subnet with several configuration pieces: option 3,
    // option 121, and a host assignment. Then delete it.
    ClientResponse response;

    DtoDhcpSubnet subnet = new DtoDhcpSubnet();
    subnet.setSubnetPrefix("172.31.0.0");
    subnet.setSubnetLength(24);
    subnet.setServerAddr("172.31.0.118");
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .post(ClientResponse.class, subnet);
    assertEquals(201, response.getStatus());
    subnet =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);

    DtoDhcpHost host1 = new DtoDhcpHost();
    host1.setMacAddr("02:33:44:55:00:00");
    host1.setIpAddr("172.31.0.11");
    host1.setName("saturn");
    response =
        resource()
            .uri(subnet.getHosts())
            .type(APPLICATION_DHCP_HOST_JSON)
            .post(ClientResponse.class, host1);
    assertEquals(201, response.getStatus());

    // List the subnets
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .accept(APPLICATION_DHCP_SUBNET_COLLECTION_JSON)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    DtoDhcpSubnet[] subnets = response.getEntity(DtoDhcpSubnet[].class);
    assertThat("We expect 1 listed subnets.", subnets, arrayWithSize(1));
    assertThat(
        "We expect the listed subnets to match the one we created.",
        subnets,
        arrayContainingInAnyOrder(subnet));

    // Now delete the subnet.
    response = resource().uri(subnet.getUri()).delete(ClientResponse.class);
    assertEquals(204, response.getStatus());
    // Show that the list of DHCP subnet configurations is empty.
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .accept(APPLICATION_DHCP_SUBNET_COLLECTION_JSON)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    subnets = response.getEntity(DtoDhcpSubnet[].class);
    assertThat("We expect 0 listed subnets.", subnets, arrayWithSize(0));
  }
Пример #7
0
  public URI put(URI uri, Object entity, String mediaType) {
    ClientResponse response = resource().uri(uri).type(mediaType).put(ClientResponse.class, entity);

    if (response.getStatus() != 204 && response.getStatus() != 200) {
      handleHttpError(response);
    }
    return response.getLocation();
  }
Пример #8
0
 private REST handle(ClientResponse response) {
   status = response.getStatus();
   location = response.getLocation();
   readEntityIfPossible(response);
   response.close();
   System.out.printf(
       "GET from [%s], status code [%d] location: %s, returned data: %n%s",
       path, status, location, entity);
   return this;
 }
  @Test(dependsOnMethods = {"testDeployApplication", "testLocatedLocation"})
  public void testDeployApplicationFromInterface() throws Exception {
    ApplicationSpec spec =
        ApplicationSpec.builder()
            .type(BasicApplication.class.getCanonicalName())
            .name("simple-app-interface")
            .locations(ImmutableSet.of("localhost"))
            .build();

    ClientResponse response = clientDeploy(spec);
    assertTrue(response.getStatus() / 100 == 2, "response is " + response);

    // Expect app to be running
    URI appUri = response.getLocation();
    waitForApplicationToBeRunning(response.getLocation());
    assertEquals(
        client().resource(appUri).get(ApplicationSummary.class).getSpec().getName(),
        "simple-app-interface");
  }
  @Test(dependsOnMethods = {"testDeleteApplication"})
  // this must happen after we've deleted the main application, as testLocatedLocations assumes a
  // single location
  public void testDeployApplicationImpl() throws Exception {
    ApplicationSpec spec =
        ApplicationSpec.builder()
            .type(RestMockApp.class.getCanonicalName())
            .name("simple-app-impl")
            .locations(ImmutableSet.of("localhost"))
            .build();

    ClientResponse response = clientDeploy(spec);
    assertTrue(response.getStatus() / 100 == 2, "response is " + response);

    // Expect app to be running
    URI appUri = response.getLocation();
    waitForApplicationToBeRunning(response.getLocation());
    assertEquals(
        client().resource(appUri).get(ApplicationSummary.class).getSpec().getName(),
        "simple-app-impl");
  }
  @Test(dependsOnMethods = {"testDeployApplication", "testLocatedLocation"})
  public void testDeployApplicationYaml() throws Exception {
    String yaml =
        "{ name: simple-app-yaml, location: localhost, services: [ { serviceType: "
            + BasicApplication.class.getCanonicalName()
            + " } ] }";

    ClientResponse response =
        client()
            .resource("/v1/applications")
            .entity(yaml, "application/x-yaml")
            .post(ClientResponse.class);
    assertTrue(response.getStatus() / 100 == 2, "response is " + response);

    // Expect app to be running
    URI appUri = response.getLocation();
    waitForApplicationToBeRunning(response.getLocation());
    assertEquals(
        client().resource(appUri).get(ApplicationSummary.class).getSpec().getName(),
        "simple-app-yaml");
  }
  @Test
  public void testTryingToAddInvalidResearcherUrls()
      throws InterruptedException, JSONException, URISyntaxException {
    String accessToken =
        getAccessToken(this.client1ClientId, this.client1ClientSecret, this.client1RedirectUri);
    assertNotNull(accessToken);
    ResearcherUrl rUrlToCreate = new ResearcherUrl();
    rUrlToCreate.setUrl(new Url(""));
    rUrlToCreate.setUrlName("");
    // Create
    ClientResponse postResponse =
        memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), postResponse.getStatus());

    String _351Chars = new String();
    for (int i = 0; i < 531; i++) {
      _351Chars += "a";
    }

    rUrlToCreate.setUrl(new Url(_351Chars));
    postResponse = memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), postResponse.getStatus());

    rUrlToCreate.setUrl(new Url("http://myurl.com"));
    rUrlToCreate.setUrlName(_351Chars);
    postResponse = memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), postResponse.getStatus());

    rUrlToCreate.setUrlName("The name");
    postResponse = memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.CREATED.getStatusCode(), postResponse.getStatus());

    // Read it to delete it
    ClientResponse getResponse =
        memberV2ApiClient.viewLocationXml(postResponse.getLocation(), accessToken);
    assertEquals(Response.Status.OK.getStatusCode(), getResponse.getStatus());
    ResearcherUrl gotResearcherUrl = getResponse.getEntity(ResearcherUrl.class);
    ClientResponse deleteResponse =
        memberV2ApiClient.deleteResearcherUrl(
            this.user1OrcidId, gotResearcherUrl.getPutCode(), accessToken);
    assertEquals(Response.Status.NO_CONTENT.getStatusCode(), deleteResponse.getStatus());
  }
 /*
  * Handle request redirects, adding cookies and setting the redirect URL
  */
 private WebResource handelRedirect(ClientResponse response) {
   URI url = response.getLocation();
   List<NewCookie> cookies = response.getCookies();
   if (cookies != null && !cookies.isEmpty()) {
     _requestCookies.addAll(cookies);
   } else {
     _logger.debug("no cookies");
   }
   if (url != null) {
     _logger.debug("redirected url: {}", url.toString());
     WebResource resource = _client.getResource(url.toString());
     return resource;
   } else {
     _logger.error("Could not find redirected url");
     return null;
   }
 }
Пример #14
0
  @Before
  public void before() {
    ClientResponse response;

    DtoApplication app = resource().path("").accept(APPLICATION_JSON_V5).get(DtoApplication.class);

    bridge = new DtoBridge();
    bridge.setName("br1234");
    bridge.setTenantId("DhcpTenant");
    response =
        resource()
            .uri(app.getBridges())
            .type(APPLICATION_BRIDGE_JSON)
            .post(ClientResponse.class, bridge);
    assertEquals("The bridge was created.", 201, response.getStatus());
    bridge =
        resource().uri(response.getLocation()).accept(APPLICATION_BRIDGE_JSON).get(DtoBridge.class);
  }
 public String createVM(String service_id, ServiceComponent sc, int index)
     throws ServiceInstantiationException {
   WebResource r = client.resource(base_url + "/optimis_compute");
   try {
     ClientResponse res =
         r.type(MediaType.APPLICATION_JSON_TYPE)
             .post(ClientResponse.class, renderCompute(service_id, sc, index));
     if (res.getStatus() != Status.CREATED.getStatusCode()) {
       throw new ServiceInstantiationException(
           "There was a problem while processing the request: " + res.getStatus(),
           new Exception());
     }
     // return res.getHeaders().get(HttpHeaders.LOCATION).get(0);
     return res.getLocation().toString();
   } catch (JSONEncodingException e) {
     throw new ServiceInstantiationException(
         "There was a problem when transforming the service component to JSON format", e);
   }
 }
  private static URI sendNodeToServer() {
    final String nodeEntryPointUri = SERVER_ROOT_URI + "node";
    // http://localhost:7474/db/data/node

    WebResource resource = Client.create().resource(nodeEntryPointUri);
    // POST {} to the node entry point URI
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_JSON)
            .entity("{}")
            .post(ClientResponse.class);

    URI location = response.getLocation();
    System.out.println(
        String.format("POST to [%s], status code [%d]", nodeEntryPointUri, response.getStatus()));
    response.close();

    return location;
  }
Пример #17
0
  @Test
  public void testEnabled() {
    ClientResponse response;

    // Create an enabled subnet
    DtoDhcpSubnet subnet1 = new DtoDhcpSubnet();
    subnet1.setSubnetPrefix("10.0.0.0");
    subnet1.setSubnetLength(24);
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON_V2)
            .post(ClientResponse.class, subnet1);
    assertEquals(201, response.getStatus());

    // Test GET
    subnet1 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON_V2)
            .get(DtoDhcpSubnet.class);
    assertEquals(true, subnet1.isEnabled());

    // Disable a subnet via update
    subnet1.setEnabled(false);
    response =
        resource()
            .uri(subnet1.getUri())
            .type(APPLICATION_DHCP_SUBNET_JSON_V2)
            .put(ClientResponse.class, subnet1);
    assertEquals(204, response.getStatus());

    subnet1 =
        resource()
            .uri(subnet1.getUri())
            .accept(APPLICATION_DHCP_SUBNET_JSON_V2)
            .get(DtoDhcpSubnet.class);
    assertEquals(false, subnet1.isEnabled());
  }
  OrganizationsResourceImpl(Link orgsLink) {

    this.orgsLink = orgsLink;

    orgsURI = UriBuilder.fromUri(BASE_URI.toString() + orgsLink.getHref().toString()).build();

    URI uri = UriBuilder.fromUri(BASE_URI.toString() + orgsLink.getHref().toString()).build();
    ClientResponse response =
        ClientUtil.readClientResponse(uri, getHttpClient(), MediaType.APPLICATION_ATOM_XML);

    PaginatedFeedEntitiesList<Organization> pgs;
    if (response.getStatus() == 200) {
      Feed feed = ClientUtil.getFeed(response);

      entries = feed.getEntries();

      orgsLink = feed.getLink(REL_ORG);

      if (response.getHeaders().getFirst("Cache-Control") != null)
        isCacheEnabled = response.getHeaders().getFirst("Cache-Control").equals("no-cache");
      String dateString = response.getHeaders().getFirst("Last-Modified");
      SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz");
      try {
        lastModifiedDate = format.parse(dateString);
      } catch (Exception ex) {
      }
      dateString = response.getHeaders().getFirst("Expires");
      try {
        lastModifiedDate = format.parse(dateString);
      } catch (Exception ex) {
      }
      uri = response.getLocation();

    } else {

      orgLink = null;
    }
  }
  private static URI addRelationship(
      URI startNode, URI endNode, String relationshipType, String jsonAttributes)
      throws URISyntaxException {
    URI fromUri = new URI(startNode.toString() + "/relationships");
    String relationshipJson = generateJsonRelationship(endNode, relationshipType, jsonAttributes);
    System.out.println(relationshipJson + "===================================");
    WebResource resource = Client.create().resource(fromUri);
    // POST JSON to the relationships URI
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_JSON)
            .entity(relationshipJson)
            .post(ClientResponse.class);

    final URI location = response.getLocation();
    System.out.println(
        String.format(
            "POST to [%s], status code [%d], location header [%s]",
            fromUri, response.getStatus(), location.toString()));
    response.close();
    return location;
  }
 private static void setRelationshipServer(String node1, String node2, String type) {
   URI fromUri = null;
   try {
     fromUri = new URI("http://localhost:7474/db/data/node/" + node1 + "/relationships/");
   } catch (URISyntaxException e1) {
     // TODO Auto-generated catch block
     e1.printStackTrace();
   }
   String endUri = "http://localhost:7474/db/data/node/" + node2;
   String relationshipJson = generateJsonRelationship(endUri, type, "rel");
   WebResource resource = Client.create().resource(fromUri);
   // POST JSON to the relationships URI
   ClientResponse response =
       resource
           .accept(MediaType.APPLICATION_JSON)
           .type(MediaType.APPLICATION_JSON)
           .entity(relationshipJson)
           .post(ClientResponse.class);
   final URI location = response.getLocation();
   System.out.println(
       String.format("POST to [%s], status code [%d]", fromUri, response.getStatus()));
   response.close();
 }
  @Test
  public void testResearcherUrl() throws InterruptedException, JSONException, URISyntaxException {
    String accessToken =
        getAccessToken(this.client1ClientId, this.client1ClientSecret, this.client1RedirectUri);
    assertNotNull(accessToken);
    ResearcherUrl rUrlToCreate =
        (ResearcherUrl)
            unmarshallFromPath(
                "/record_2.0_rc2/samples/researcher-url-2.0_rc2.xml", ResearcherUrl.class);
    assertNotNull(rUrlToCreate);
    Long time = System.currentTimeMillis();
    rUrlToCreate.setCreatedDate(null);
    rUrlToCreate.setLastModifiedDate(null);
    rUrlToCreate.setPath(null);
    rUrlToCreate.setPutCode(null);
    rUrlToCreate.setSource(null);
    rUrlToCreate.setUrl(new Url(rUrlToCreate.getUrl().getValue() + time));
    rUrlToCreate.setUrlName(String.valueOf(time));

    // Create
    ClientResponse postResponse =
        memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.CREATED.getStatusCode(), postResponse.getStatus());
    String locationPath = postResponse.getLocation().getPath();
    assertTrue(
        "Location header path should match pattern, but was " + locationPath,
        locationPath.matches(".*/v2.0_rc2/" + user1OrcidId + "/researcher-urls/\\d+"));

    // Read
    ClientResponse getResponse =
        memberV2ApiClient.viewLocationXml(postResponse.getLocation(), accessToken);
    assertEquals(Response.Status.OK.getStatusCode(), getResponse.getStatus());
    ResearcherUrl gotResearcherUrl = getResponse.getEntity(ResearcherUrl.class);
    assertNotNull(gotResearcherUrl);
    assertNotNull(gotResearcherUrl.getPutCode());
    assertNotNull(gotResearcherUrl.getSource());
    assertNotNull(gotResearcherUrl.getCreatedDate());
    assertNotNull(gotResearcherUrl.getLastModifiedDate());
    assertEquals(this.client1ClientId, gotResearcherUrl.getSource().retrieveSourcePath());
    assertEquals("http://site1.com/" + time, gotResearcherUrl.getUrl().getValue());
    assertEquals(String.valueOf(time), gotResearcherUrl.getUrlName());
    assertEquals("public", gotResearcherUrl.getVisibility().value());

    // Update
    LastModifiedDate initialLastModified = gotResearcherUrl.getLastModifiedDate();
    Long currentTime = System.currentTimeMillis();
    gotResearcherUrl.setUrlName(gotResearcherUrl.getUrlName() + " - " + currentTime);
    gotResearcherUrl.getUrl().setValue(gotResearcherUrl.getUrl().getValue() + currentTime);
    gotResearcherUrl.setVisibility(Visibility.LIMITED);
    ClientResponse updatedResearcherUrlResponse =
        memberV2ApiClient.updateResearcherUrls(this.user1OrcidId, gotResearcherUrl, accessToken);
    assertNotNull(updatedResearcherUrlResponse);
    assertEquals(Response.Status.OK.getStatusCode(), updatedResearcherUrlResponse.getStatus());
    ResearcherUrl updatedResearcherUrl =
        updatedResearcherUrlResponse.getEntity(ResearcherUrl.class);
    assertNotNull(updatedResearcherUrl);
    assertEquals(
        "http://site1.com/" + time + currentTime, updatedResearcherUrl.getUrl().getValue());
    assertEquals(String.valueOf(time) + " - " + currentTime, updatedResearcherUrl.getUrlName());
    // Keep it public, since it is more restrictive than the user visibility
    // default
    assertEquals("public", updatedResearcherUrl.getVisibility().value());
    assertFalse(initialLastModified.equals(updatedResearcherUrl.getLastModifiedDate()));

    // Delete
    ClientResponse deleteResponse =
        memberV2ApiClient.deleteResearcherUrl(
            this.user1OrcidId, gotResearcherUrl.getPutCode(), accessToken);
    assertEquals(Response.Status.NO_CONTENT.getStatusCode(), deleteResponse.getStatus());
  }
Пример #22
0
  // @Test
  public void testSubnetCreateGetListDelete() {
    ClientResponse response;

    // Create a subnet
    DtoDhcpSubnet subnet1 = new DtoDhcpSubnet();
    subnet1.setSubnetPrefix("172.31.0.0");
    subnet1.setSubnetLength(24);
    subnet1.setServerAddr("172.31.0.118");
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .post(ClientResponse.class, subnet1);
    assertEquals(201, response.getStatus());
    // Test GET
    subnet1 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);
    assertEquals("172.31.0.0", subnet1.getSubnetPrefix());
    assertEquals(24, subnet1.getSubnetLength());

    // Create another subnet
    DtoDhcpSubnet subnet2 = new DtoDhcpSubnet();
    subnet2.setSubnetPrefix("172.31.1.0");
    subnet2.setSubnetLength(24);
    subnet2.setServerAddr("172.31.1.118");
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .post(ClientResponse.class, subnet2);
    assertEquals(201, response.getStatus());
    subnet2 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);
    assertEquals("172.31.1.0", subnet2.getSubnetPrefix());
    assertEquals(24, subnet2.getSubnetLength());

    // List the subnets
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .accept(APPLICATION_DHCP_SUBNET_COLLECTION_JSON)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    DtoDhcpSubnet[] subnets = response.getEntity(DtoDhcpSubnet[].class);
    assertThat("We expect 2 listed subnets.", subnets, arrayWithSize(2));
    assertThat(
        "We expect the listed subnets to match those we created.",
        subnets,
        arrayContainingInAnyOrder(subnet1, subnet2));

    // Delete the first subnet
    response = resource().uri(subnet1.getUri()).delete(ClientResponse.class);
    assertEquals(204, response.getStatus());
    // There should now be only the second subnet.
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .accept(APPLICATION_DHCP_SUBNET_COLLECTION_JSON)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    subnets = response.getEntity(DtoDhcpSubnet[].class);
    assertThat("We expect 1 listed subnet after the delete", subnets, arrayWithSize(1));
    assertThat(
        "The listed subnet should be the one that wasn't deleted.",
        subnets,
        arrayContainingInAnyOrder(subnet2));

    // Test GET of a non-existing subnet (the deleted first subnet).
    response =
        resource()
            .uri(subnet1.getUri())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(ClientResponse.class);
    assertEquals(404, response.getStatus());
  }
Пример #23
0
  @Test
  public void testDhcpRoutes() {
    ClientResponse response;

    DtoDhcpSubnet subnet1 = new DtoDhcpSubnet();
    subnet1.setSubnetPrefix("172.0.0.0");
    subnet1.setSubnetLength(24);
    subnet1.setDefaultGateway("172.0.0.254");
    subnet1.setServerAddr("172.0.0.118");
    subnet1.getOpt121Routes().add(new DtoDhcpOption121("172.31.1.0", 24, "172.0.0.253"));
    subnet1.getOpt121Routes().add(new DtoDhcpOption121("172.31.2.0", 24, "172.0.0.253"));
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .post(ClientResponse.class, subnet1);
    assertEquals(201, response.getStatus());
    DtoDhcpSubnet subnet2 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);

    // Copy the URIs from the GET to the DTO we used for create.
    subnet1.setHosts(subnet2.getHosts());
    subnet1.setUri(subnet2.getUri());
    // Now the DTOs should be identical.

    assertEquals(
        "The DhcpSubnet client dto from GET should be " + "identical to the one passed to create",
        subnet1,
        subnet2);

    // Now modify the routes and do an update.
    subnet1.getOpt121Routes().remove(0);
    subnet1.getOpt121Routes().add(new DtoDhcpOption121("172.31.3.0", 24, "172.0.0.252"));
    subnet1.getOpt121Routes().add(new DtoDhcpOption121("172.31.4.0", 24, "172.0.0.253"));
    subnet1.setDefaultGateway("172.0.0.1");
    response =
        resource()
            .uri(subnet1.getUri())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .put(ClientResponse.class, subnet1);
    assertEquals(204, response.getStatus());
    subnet2 =
        resource()
            .uri(subnet1.getUri())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);
    // The URIs should not have changed, so the DTOs should be identical.
    assertEquals(
        "The DhcpSubnet client dto from GET should be " + "identical to the one passed to create",
        subnet1,
        subnet2);

    // Now try removing all routes.
    subnet1.getOpt121Routes().clear();
    subnet1.setDefaultGateway(null);
    response =
        resource()
            .uri(subnet1.getUri())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .put(ClientResponse.class, subnet1);
    assertEquals(204, response.getStatus());
    subnet2 =
        resource()
            .uri(subnet1.getUri())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);
    // The URIs should not have changed, so the DTOs should be identical.
    assertEquals(
        "The DhcpSubnet client dto from GET should be " + "identical to the one passed to create",
        subnet1,
        subnet2);
  }
Пример #24
0
  @Test
  public void testHosts() {
    // In this test remember that there will be multiple host definitions.
    // The system enforces that there is only one host def per mac address.
    ClientResponse response;

    DtoDhcpSubnet subnet = new DtoDhcpSubnet();
    subnet.setSubnetPrefix("172.31.0.0");
    subnet.setSubnetLength(24);
    subnet.setServerAddr("172.31.0.118");
    response =
        resource()
            .uri(bridge.getDhcpSubnets())
            .type(APPLICATION_DHCP_SUBNET_JSON)
            .post(ClientResponse.class, subnet);
    assertEquals(201, response.getStatus());
    subnet =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_SUBNET_JSON)
            .get(DtoDhcpSubnet.class);

    DtoDhcpHost host1 = new DtoDhcpHost();
    List<DtoExtraDhcpOpt> opts = new ArrayList<>();
    opts.add(new DtoExtraDhcpOpt("name1", "val1"));
    opts.add(new DtoExtraDhcpOpt("name2", "val2"));
    opts.add(new DtoExtraDhcpOpt("name3", "val3"));
    host1.setMacAddr("02:33:44:55:00:00");
    host1.setIpAddr("172.31.0.11");
    host1.setName("saturn");
    host1.setExtraDhcpOpts(opts);
    response =
        resource()
            .uri(subnet.getHosts())
            .type(APPLICATION_DHCP_HOST_JSON_V2)
            .post(ClientResponse.class, host1);
    assertEquals(201, response.getStatus());
    host1 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_HOST_JSON_V2)
            .get(DtoDhcpHost.class);
    assertEquals("02:33:44:55:00:00", host1.getMacAddr());
    assertEquals("172.31.0.11", host1.getIpAddr());
    assertEquals("saturn", host1.getName());
    assertEquals(opts, host1.getExtraDhcpOpts());

    DtoDhcpHost host2 = new DtoDhcpHost();
    host2.setMacAddr("02:33:44:55:00:01");
    host2.setIpAddr("172.31.0.12");
    host2.setName("jupiter");
    List<DtoExtraDhcpOpt> opts2 = new ArrayList<>();
    opts2.add(new DtoExtraDhcpOpt("name1", "val1"));
    opts2.add(new DtoExtraDhcpOpt("name2", "val2"));
    opts2.add(new DtoExtraDhcpOpt("name3", "val3"));
    host2.setExtraDhcpOpts(opts2);
    response =
        resource()
            .uri(subnet.getHosts())
            .type(APPLICATION_DHCP_HOST_JSON_V2)
            .post(ClientResponse.class, host2);
    assertEquals(201, response.getStatus());
    host2 =
        resource()
            .uri(response.getLocation())
            .accept(APPLICATION_DHCP_HOST_JSON_V2)
            .get(DtoDhcpHost.class);
    assertEquals("02:33:44:55:00:01", host2.getMacAddr());
    assertEquals("172.31.0.12", host2.getIpAddr());
    assertEquals("jupiter", host2.getName());
    assertEquals(opts, host2.getExtraDhcpOpts());

    // Now list all the host static assignments.
    response =
        resource()
            .uri(subnet.getHosts())
            .accept(APPLICATION_DHCP_HOST_COLLECTION_JSON_V2)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());

    DtoDhcpHost[] hosts = response.getEntity(DtoDhcpHost[].class);
    assertThat("We expect 2 listed hosts.", hosts, arrayWithSize(2));
    assertThat(
        "We expect the listed hosts to match those we created.",
        hosts,
        arrayContainingInAnyOrder(host2, host1));

    // Now try to create a new host with host1's mac address. This should
    // fail.
    host1.setIpAddr("172.31.0.13");
    response =
        resource()
            .uri(subnet.getHosts())
            .type(APPLICATION_DHCP_HOST_JSON_V2)
            .post(ClientResponse.class, host1);
    assertEquals(409, response.getStatus());

    // Try again, this time using an UPDATE operation.
    response =
        resource()
            .uri(host1.getUri())
            .type(APPLICATION_DHCP_HOST_JSON_V2)
            .put(ClientResponse.class, host1);
    assertEquals(204, response.getStatus());
    host1 =
        resource().uri(host1.getUri()).accept(APPLICATION_DHCP_HOST_JSON_V2).get(DtoDhcpHost.class);
    assertEquals("02:33:44:55:00:00", host1.getMacAddr());
    assertEquals("172.31.0.13", host1.getIpAddr());
    assertEquals("saturn", host1.getName());

    // There should still be exactly 2 host assignments.
    response =
        resource()
            .uri(subnet.getHosts())
            .accept(APPLICATION_DHCP_HOST_COLLECTION_JSON_V2)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    hosts = response.getEntity(DtoDhcpHost[].class);
    assertThat("We expect 2 listed hosts.", hosts, arrayWithSize(2));
    assertThat(
        "We expect the listed hosts to match those we created.",
        hosts,
        arrayContainingInAnyOrder(host1, host2));

    // Now delete one of the host assignments.
    response = resource().uri(host1.getUri()).delete(ClientResponse.class);
    assertEquals(204, response.getStatus());
    // There should now be only 1 host assignment.
    response =
        resource()
            .uri(subnet.getHosts())
            .accept(APPLICATION_DHCP_HOST_COLLECTION_JSON_V2)
            .get(ClientResponse.class);
    assertEquals(200, response.getStatus());
    hosts = response.getEntity(DtoDhcpHost[].class);
    assertThat("We expect 1 listed host after the delete", hosts, arrayWithSize(1));
    assertThat(
        "The listed hosts should be the one that wasn't deleted.",
        hosts,
        arrayContainingInAnyOrder(host2));
  }