@Test
  public void testCantAddDuplicatedResearcherUrl()
      throws InterruptedException, JSONException, URISyntaxException {
    String accessToken =
        getAccessToken(this.client1ClientId, this.client1ClientSecret, this.client1RedirectUri);
    assertNotNull(accessToken);
    Long now = System.currentTimeMillis();
    ResearcherUrl rUrlToCreate = new ResearcherUrl();
    rUrlToCreate.setUrl(new Url("http://newurl.com/" + now));
    rUrlToCreate.setUrlName("url-name-" + System.currentTimeMillis());
    rUrlToCreate.setVisibility(Visibility.PUBLIC);

    // Create it
    ClientResponse postResponse =
        memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.CREATED.getStatusCode(), postResponse.getStatus());

    // Add it again
    postResponse = memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.CONFLICT.getStatusCode(), postResponse.getStatus());

    // Check it can be created by other client
    String otherClientToken =
        getAccessToken(this.client2ClientId, this.client2ClientSecret, this.client2RedirectUri);
    postResponse =
        memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, otherClientToken);
    assertNotNull(postResponse);
    assertEquals(Response.Status.CREATED.getStatusCode(), postResponse.getStatus());
  }
  static void testUpload(TestParams testParams) throws Exception {

    FormDataMultiPart part = new FormDataMultiPart();

    part.field(RestParams.COMMIT_ID, QUERY_PARAMS.get(RestParams.COMMIT_ID));
    part.field(RestParams.MODULE_GROUPID, QUERY_PARAMS.get(RestParams.MODULE_GROUPID));
    part.field(RestParams.MODULE_ARTIFACTID, QUERY_PARAMS.get(RestParams.MODULE_ARTIFACTID));
    part.field(RestParams.MODULE_VERSION, QUERY_PARAMS.get(RestParams.MODULE_VERSION));
    part.field(RestParams.USERNAME, QUERY_PARAMS.get(RestParams.USERNAME));
    part.field(RestParams.VCS_REPO_URL, "ssh://[email protected]:7999/chop/main.git");
    part.field(RestParams.TEST_PACKAGE, QUERY_PARAMS.get(RestParams.TEST_PACKAGE));
    part.field(RestParams.MD5, "d7d4829506f6cb8c0ab2da9cb1daca02");

    File tmpFile = File.createTempFile("runner", "jar");
    FileInputStream in = new FileInputStream(tmpFile);
    FormDataBodyPart body =
        new FormDataBodyPart(RestParams.CONTENT, in, MediaType.APPLICATION_OCTET_STREAM_TYPE);
    part.bodyPart(body);

    ClientResponse response =
        testParams
            .addQueryParameters(QUERY_PARAMS)
            .setEndpoint(UploadResource.ENDPOINT)
            .newWebResource()
            .path("/runner")
            .type(MediaType.MULTIPART_FORM_DATA)
            .accept(MediaType.TEXT_PLAIN)
            .post(ClientResponse.class, part);

    assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());

    assertEquals(UploadResource.SUCCESSFUL_TEST_MESSAGE, response.getEntity(String.class));

    tmpFile.delete();
  }
  @Test
  public void testRestoreShouldReturnOkResponse() throws Exception {
    doReturn(new BackupInfo()).when(mockFacade).restore(any(BackupConfig.class));

    Response result = service.restore(ARTIFACT_NAME, "");
    assertEquals(result.getStatus(), Response.Status.CREATED.getStatusCode());
  }
  @Test
  public void testAddNodeShouldReturnOkResponse() throws Exception {
    doReturn(new NodeInfo()).when(mockFacade).addNode("dns");

    Response result = service.addNode("dns");
    assertEquals(result.getStatus(), Response.Status.CREATED.getStatusCode());
  }
  @Test
  public void testSubmit() throws Exception {
    for (HierarchicalTypeDefinition typeDefinition : typeDefinitions) {
      String typesAsJSON = TypesSerialization.toJson(typeDefinition);
      System.out.println("typesAsJSON = " + typesAsJSON);

      WebResource resource = service.path("api/atlas/types");

      ClientResponse clientResponse =
          resource
              .accept(Servlets.JSON_MEDIA_TYPE)
              .type(Servlets.JSON_MEDIA_TYPE)
              .method(HttpMethod.POST, ClientResponse.class, typesAsJSON);
      assertEquals(clientResponse.getStatus(), Response.Status.CREATED.getStatusCode());

      String responseAsString = clientResponse.getEntity(String.class);
      Assert.assertNotNull(responseAsString);

      JSONObject response = new JSONObject(responseAsString);
      JSONArray typesAdded = response.getJSONArray(AtlasClient.TYPES);
      assertEquals(typesAdded.length(), 1);
      assertEquals(typesAdded.getJSONObject(0).getString("name"), typeDefinition.typeName);
      Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));
    }
  }
  @Test(dependsOnMethods = "testGetTraitNames")
  public void testAddTrait() throws Exception {
    traitName = "PII_Trait" + randomString();
    HierarchicalTypeDefinition<TraitType> piiTrait =
        TypesUtil.createTraitTypeDef(traitName, ImmutableList.<String>of());
    String traitDefinitionAsJSON = TypesSerialization$.MODULE$.toJson(piiTrait, true);
    LOG.debug("traitDefinitionAsJSON = " + traitDefinitionAsJSON);
    createType(traitDefinitionAsJSON);

    Struct traitInstance = new Struct(traitName);
    String traitInstanceAsJSON = InstanceSerialization.toJson(traitInstance, true);
    LOG.debug("traitInstanceAsJSON = " + traitInstanceAsJSON);

    final String guid = tableId._getId();
    ClientResponse clientResponse =
        service
            .path(ENTITIES)
            .path(guid)
            .path(TRAITS)
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(HttpMethod.POST, ClientResponse.class, traitInstanceAsJSON);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.CREATED.getStatusCode());

    String responseAsString = clientResponse.getEntity(String.class);
    Assert.assertNotNull(responseAsString);

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));
    Assert.assertNotNull(response.get(AtlasClient.GUID));
  }
  @Test
  public void testUpdateCodenvyProperty() throws Exception {
    Map<String, String> properties = ImmutableMap.of("x", "y");

    Response response = service.updateCodenvyProperties(properties);
    assertEquals(response.getStatus(), Response.Status.CREATED.getStatusCode());
    verify(mockFacade).updateArtifactConfig(any(Artifact.class), anyMap());
  }
  public void addCatalog() {
    Response response = services.getCatalogService().request().post(Entity.xml(catalogItem));

    Response.StatusType statusInfo = response.getStatusInfo();

    if (statusInfo.getStatusCode() == Response.Status.CREATED.getStatusCode())
      status = "User added successfully";
    else status = statusInfo.getReasonPhrase();
  }
  @Test
  public void testAddTrialSubscriptionShouldReturnOkResponse() throws Exception {
    SaasUserCredentials testUserCredentials =
        new SaasUserCredentials(TEST_ACCESS_TOKEN, TEST_ACCOUNT_ID);
    service.saasUserCredentials = testUserCredentials;

    Response result = service.addTrialSubscription();
    assertEquals(result.getStatus(), Response.Status.CREATED.getStatusCode());
    verify(mockFacade).addTrialSaasSubscription(testUserCredentials);
  }
  @Test
  public void createCollectionObject() {
    long identifier = this.createIdentifier();

    CollectionObject collectionObject = createCollectionObject(identifier);
    ClientResponse<Response> res = collectionObjectClient.createCollectionObject(collectionObject);
    Assert.assertEquals(res.getStatus(), Response.Status.CREATED.getStatusCode());

    // store updateId locally for "update" test
    if (updateId == null) updateId = extractId(res);
    else deleteId = extractId(res);
  }
Beispiel #11
0
  private Airplane addAirplane(Airplane airplane) {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(rootURI + "/airplanes");

    Response response = target.request().post(Entity.entity(airplane, MediaType.APPLICATION_JSON));
    Airplane updated = response.readEntity(Airplane.class);

    response.close();

    Assert.assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());

    return updated;
  }
  /* post(null) /wishlists/wishlistId/media */
  @Test
  public void testPostByWishlistIdMedia() throws FileNotFoundException {
    Response response = createWishlistMedia();

    // Verify
    assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());
    String location =
        response
            .getHeaderString("location")
            .substring(response.getHeaderString("location").lastIndexOf("/") + 1);
    instanceListMedia.add(location);
    assertNotNull(location);
  }
 @Test
 public void testSaveAccount() {
   Account account = new Account();
   account.setUsername("testUser");
   Client client = ClientBuilder.newClient();
   WebTarget target =
       client.target("http://localhost:8080/employee-manager-container/rest/account");
   Response response =
       target
           .request(MediaType.APPLICATION_JSON)
           .post(Entity.entity(account, MediaType.APPLICATION_JSON_TYPE));
   assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());
 }
  @Test(dependsOnMethods = "testGetTraitNames")
  public void testAddTraitWithAttribute() throws Exception {
    final String traitName = "PII_Trait" + randomString();
    HierarchicalTypeDefinition<TraitType> piiTrait =
        TypesUtil.createTraitTypeDef(
            traitName,
            ImmutableList.<String>of(),
            TypesUtil.createRequiredAttrDef("type", DataTypes.STRING_TYPE));
    String traitDefinitionAsJSON = TypesSerialization$.MODULE$.toJson(piiTrait, true);
    LOG.debug("traitDefinitionAsJSON = " + traitDefinitionAsJSON);
    createType(traitDefinitionAsJSON);

    Struct traitInstance = new Struct(traitName);
    traitInstance.set("type", "SSN");
    String traitInstanceAsJSON = InstanceSerialization.toJson(traitInstance, true);
    LOG.debug("traitInstanceAsJSON = " + traitInstanceAsJSON);

    final String guid = tableId._getId();
    ClientResponse clientResponse =
        service
            .path(ENTITIES)
            .path(guid)
            .path(TRAITS)
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(HttpMethod.POST, ClientResponse.class, traitInstanceAsJSON);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.CREATED.getStatusCode());

    String responseAsString = clientResponse.getEntity(String.class);
    Assert.assertNotNull(responseAsString);

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));
    Assert.assertNotNull(response.get(AtlasClient.GUID));

    // verify the response
    clientResponse = getEntityDefinition(guid);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode());
    responseAsString = clientResponse.getEntity(String.class);
    Assert.assertNotNull(responseAsString);
    response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));

    final String definition = response.getString(AtlasClient.DEFINITION);
    Assert.assertNotNull(definition);
    Referenceable entityRef = InstanceSerialization.fromJsonReferenceable(definition, true);
    IStruct traitRef = entityRef.getTrait(traitName);
    String type = (String) traitRef.get("type");
    Assert.assertEquals(type, "SSN");
  }
  @Test
  public void testAddMultipleResearcherUrlAndGetThem()
      throws InterruptedException, JSONException, URISyntaxException {
    String accessToken =
        getAccessToken(this.client1ClientId, this.client1ClientSecret, this.client1RedirectUri);
    assertNotNull(accessToken);
    Long now = System.currentTimeMillis();
    ResearcherUrl rUrlToCreate = new ResearcherUrl();
    rUrlToCreate.setVisibility(Visibility.PUBLIC);

    for (int i = 0; i < 3; i++) {
      // Change the name
      rUrlToCreate.setUrlName("url-name-" + now + "-" + i);
      rUrlToCreate.setUrl(new Url("http://newurl.com/" + now + "/" + i));
      // Create it
      ClientResponse postResponse =
          memberV2ApiClient.createResearcherUrls(user1OrcidId, rUrlToCreate, accessToken);
      assertNotNull(postResponse);
      assertEquals(Response.Status.CREATED.getStatusCode(), postResponse.getStatus());
    }

    ClientResponse getAllResponse =
        memberV2ApiClient.getResearcherUrls(this.user1OrcidId, accessToken);
    assertNotNull(getAllResponse);
    ResearcherUrls researcherUrls = getAllResponse.getEntity(ResearcherUrls.class);
    assertNotNull(researcherUrls);
    assertNotNull(researcherUrls.getPath());
    assertTrue(researcherUrls.getPath().contains(this.user1OrcidId));
    assertNotNull(researcherUrls.getResearcherUrls());

    boolean found1 = false, found2 = false, found3 = false;

    for (ResearcherUrl rUrl : researcherUrls.getResearcherUrls()) {
      if (rUrl.getUrlName().equals("url-name-" + now + "-0")) {
        found1 = true;
      } else if (rUrl.getUrlName().equals("url-name-" + now + "-1")) {
        found2 = true;
      } else if (rUrl.getUrlName().equals("url-name-" + now + "-2")) {
        found3 = true;
      }
    }

    assertTrue(found1 && found2 && found3);

    // Clean
    for (ResearcherUrl rUrl : researcherUrls.getResearcherUrls()) {
      memberV2ApiClient.deletePeerReviewXml(this.user1OrcidId, rUrl.getPutCode(), accessToken);
    }
  }
  public static void main(String... args) {
    Client client = createClient();

    Payment payment = new Payment("123", "567", 10005, "Reimbursement for dinner");
    Entity<Payment> entity = Entity.entity(payment, MediaType.APPLICATION_JSON_TYPE);
    Invocation request = client.target(PAYMENTS_URL).request().buildPut(entity);

    Response response = request.invoke();

    int status = response.getStatus();
    if (Response.Status.CREATED.getStatusCode() == status) {
      System.out.println("Payment sent");
    } else {
      System.out.println("Error sending payment: " + status);
    }
  }
  static void testSetup(TestParams testParams) {
    ClientResponse response =
        testParams
            .addQueryParameters(QUERY_PARAMS)
            .setEndpoint(SetupResource.ENDPOINT)
            .newWebResource()
            .queryParam(RestParams.RUNNER_COUNT, "5")
            .path("/stack")
            .type(MediaType.APPLICATION_JSON)
            .accept(MediaType.APPLICATION_JSON)
            .post(ClientResponse.class);

    assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());

    assertEquals("\"NotFound\"", response.getEntity(String.class));
  }
  @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());
  }
  @Test
  public void testPostDomainFile() throws URISyntaxException {
    WebResource resource = resource();
    resource.path("testClientId").path("target").path("problem").delete();

    File targetProblemFile = new File(ClassLoader.getSystemResource("pa_target_prob.txt").toURI());
    FormDataMultiPart targetProblemForm = new FormDataMultiPart();
    targetProblemForm.bodyPart(
        new FileDataBodyPart("file", targetProblemFile, MediaType.valueOf(MediaType.TEXT_PLAIN)));
    ClientResponse response =
        resource
            .path("testClientId")
            .path("target")
            .path("problem")
            .type(MediaType.MULTIPART_FORM_DATA_TYPE)
            .post(ClientResponse.class, targetProblemForm);

    assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());
  }
Beispiel #20
0
  @Test
  public void testCreateReport() {
    // Setup
    Integer jobId = 1;
    CommandRegistry mockCommandRegistry = createMockCommandRegistry();
    ReportCommand reportCommand = createReportCommand();
    expect(mockCommandRegistry.<ReportCommandOptions>newCommand(reportCommand.getName()))
        .andReturn(reportCommand)
        .atLeastOnce();

    CommandJobService mockCommandJobService = createMockCommandJobService();
    expect(
            mockCommandJobService.launchCommand(
                eqCommandJob(createCommandJob(jobId, reportCommand, null))))
        .andReturn(jobId)
        .atLeastOnce();

    WebShellResource sut = new WebShellResource();
    sut.setCommandJobService(mockCommandJobService);
    sut.setCommandRegistry(mockCommandRegistry);

    replay(mockCommandRegistry, mockCommandJobService);

    // Exercise
    ReportCommandOptionsDto optionsDto = createReportCommandOptionsDto("test report", "project1");
    Response response = sut.createReport(optionsDto);

    // Verify mocks
    verify(mockCommandRegistry, mockCommandJobService);

    // Verify that the options in the dto were applied to the launched command
    ReportCommandOptions importOptions = reportCommand.getOptions();
    assertThat(optionsDto.getName()).isEqualTo(importOptions.getName());

    // Verify that the HTTP response code was CREATED (201) and that the "Location"
    // header was set to '/shell/command/{jobId}'.
    assertThat(response.getStatus()).isEqualTo(Response.Status.CREATED.getStatusCode());
    assertThat(response.getMetadata().getFirst("Location").toString())
        .isEqualTo("/shell/command/" + jobId);
  }
  @Test
  public void testSubmitSingleEntity() throws Exception {
    Referenceable databaseInstance = new Referenceable(DATABASE_TYPE);
    databaseInstance.set("name", randomString());
    databaseInstance.set("description", randomString());

    ClientResponse clientResponse =
        service
            .path(ENTITIES)
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(
                HttpMethod.POST,
                ClientResponse.class,
                InstanceSerialization.toJson(databaseInstance, true));
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.CREATED.getStatusCode());

    String responseAsString = clientResponse.getEntity(String.class);
    Assert.assertNotNull(responseAsString);

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));
    Assert.assertNotNull(response.get(AtlasClient.GUID));
  }
Beispiel #22
0
/** The implementation of RestSBController. */
@Component(immediate = true)
@Service
public class RestSBControllerImpl implements RestSBController {

  private static final Logger log = LoggerFactory.getLogger(RestSBControllerImpl.class);
  private static final String APPLICATION = "application/";
  private static final String XML = "xml";
  private static final String JSON = "json";
  private static final String DOUBLESLASH = "//";
  private static final String COLON = ":";
  private static final int STATUS_OK = Response.Status.OK.getStatusCode();
  private static final int STATUS_CREATED = Response.Status.CREATED.getStatusCode();
  private static final int STATUS_ACCEPTED = Response.Status.ACCEPTED.getStatusCode();
  private static final String SLASH = "/";

  private final Map<DeviceId, RestSBDevice> deviceMap = new ConcurrentHashMap<>();
  Client client;

  @Activate
  public void activate(ComponentContext context) {
    client = Client.create();
    log.info("Started");
  }

  @Deactivate
  public void deactivate() {
    deviceMap.clear();
    log.info("Stopped");
  }

  @Override
  public Map<DeviceId, RestSBDevice> getDevices() {
    return deviceMap;
  }

  @Override
  public RestSBDevice getDevice(DeviceId deviceInfo) {
    return deviceMap.get(deviceInfo);
  }

  @Override
  public RestSBDevice getDevice(IpAddress ip, int port) {
    for (DeviceId info : deviceMap.keySet()) {
      if (IpAddress.valueOf(info.uri().getHost()).equals(ip) && info.uri().getPort() == port) {
        return deviceMap.get(info);
      }
    }
    return null;
  }

  @Override
  public void addDevice(RestSBDevice device) {
    deviceMap.put(device.deviceId(), device);
  }

  @Override
  public void removeDevice(RestSBDevice device) {
    deviceMap.remove(device.deviceId());
  }

  @Override
  public boolean post(DeviceId device, String request, InputStream payload, String mediaType) {
    WebResource webResource = getWebResource(device, request);

    ClientResponse response = null;
    if (payload != null) {
      try {
        response =
            webResource
                .accept(mediaType)
                .post(ClientResponse.class, IOUtils.toString(payload, StandardCharsets.UTF_8));
      } catch (IOException e) {
        log.error(
            "Cannot do POST {} request on device {} because can't read payload", request, device);
      }
    } else {
      response = webResource.accept(mediaType).post(ClientResponse.class);
    }
    return checkReply(response);
  }

  @Override
  public boolean put(DeviceId device, String request, InputStream payload, String mediaType) {

    WebResource webResource = getWebResource(device, request);
    ClientResponse response = null;
    if (payload != null) {
      try {
        response =
            webResource
                .accept(mediaType)
                .put(ClientResponse.class, IOUtils.toString(payload, StandardCharsets.UTF_8));
      } catch (IOException e) {
        log.error(
            "Cannot do PUT {} request on device {} because can't read payload", request, device);
      }
    } else {
      response = webResource.accept(mediaType).put(ClientResponse.class);
    }
    return checkReply(response);
  }

  @Override
  public InputStream get(DeviceId device, String request, String mediaType) {
    WebResource webResource = getWebResource(device, request);
    String type;
    switch (mediaType) {
      case XML:
        type = MediaType.APPLICATION_XML;
        break;
      case JSON:
        type = MediaType.APPLICATION_JSON;
        break;
      default:
        throw new IllegalArgumentException("Unsupported media type " + mediaType);
    }
    return new ByteArrayInputStream(
        webResource
            .accept(type)
            .get(ClientResponse.class)
            .getEntity(String.class)
            .getBytes(StandardCharsets.UTF_8));
  }

  @Override
  public boolean delete(DeviceId device, String request, InputStream payload, String mediaType) {
    WebResource webResource = getWebResource(device, request);
    ClientResponse response = null;
    if (payload != null) {
      try {
        response =
            webResource
                .accept(mediaType)
                .delete(ClientResponse.class, IOUtils.toString(payload, StandardCharsets.UTF_8));
      } catch (IOException e) {
        log.error(
            "Cannot do PUT {} request on device {} because can't read payload", request, device);
      }
    } else {
      response = webResource.accept(mediaType).delete(ClientResponse.class);
    }
    return checkReply(response);
  }

  private WebResource getWebResource(DeviceId device, String request) {
    return Client.create()
        .resource(
            deviceMap.get(device).protocol()
                + COLON
                + DOUBLESLASH
                + deviceMap.get(device).ip().toString()
                + COLON
                + deviceMap.get(device).port()
                + SLASH
                + request);
  }

  private boolean checkReply(ClientResponse response) {
    if (response != null) {
      if (response.getStatus() == STATUS_OK
          || response.getStatus() == STATUS_CREATED
          || response.getStatus() == STATUS_ACCEPTED) {
        return true;
      } else {
        log.error("Failed request: HTTP error code : " + response.getStatus());
        return false;
      }
    }
    log.error("Null reply from device");
    return false;
  }
}
  /**
   * Write the specified document to the DDS using RESTful API.
   *
   * @param document The DDS meta-data wrapped document to write to DDS.
   * @throws UnsupportedEncodingException If the name of the document (nsaId, type, documentId)
   *     cannot be URL encoded.
   * @throws IOException If the document cannot be written to the DDS.
   */
  private void writeDocument(DocumentType document)
      throws UnsupportedEncodingException, IOException {
    // Wrap the provided DDS document in a JAXB element for sending.
    JAXBElement<DocumentType> request = ddsFactory.createDocument(document);

    // Build the full document path based on identifiers.
    WebTarget path;
    try {
      path =
          dds.path(URLEncoder.encode(document.getNsa().trim(), "UTF-8"))
              .path(URLEncoder.encode(document.getType().trim(), "UTF-8"))
              .path(URLEncoder.encode(document.getId().trim(), "UTF-8"));
    } catch (UnsupportedEncodingException ex) {
      log.error(
          "Could not format URL "
              + document.getNsa()
              + "/"
              + document.getType()
              + "/"
              + document.getId(),
          ex);
      throw ex;
    }

    // Determine of the NSA document already exists.
    Response response = path.request(NsiConstants.NSI_DDS_V1_XML).get();
    int status = response.getStatus();
    response.close();

    // If the document exists we modify it through PUT, otherwise we use POST.
    if (Response.Status.OK.getStatusCode() == status) {
      // Document already exists so we will need to modify it.
      Response result =
          path.request(NsiConstants.NSI_DDS_V1_XML)
              .put(
                  Entity.entity(
                      new GenericEntity<JAXBElement<DocumentType>>(request) {},
                      NsiConstants.NSI_DDS_V1_XML));
      status = result.getStatus();
      result.close();
      if (Response.Status.OK.getStatusCode() != status) {
        throw new IOException(error("PUT", status, path.getUri().toASCIIString()));
      }
    } else if (Response.Status.NOT_FOUND.getStatusCode() == response.getStatus()) {
      // Document does not exist so we will need to add it.  We POST the
      // new document under "/documents" and not the full path of the
      // document.
      Response result =
          dds.request(NsiConstants.NSI_DDS_V1_XML)
              .post(
                  Entity.entity(
                      new GenericEntity<JAXBElement<DocumentType>>(request) {},
                      NsiConstants.NSI_DDS_V1_XML));
      status = result.getStatus();
      result.close();
      if (Response.Status.CREATED.getStatusCode() != status) {
        throw new IOException(error("POST", status, path.getUri().toASCIIString()));
      }
    } else {
      throw new IOException(error("GET", status, path.getUri().toASCIIString()));
    }
  }
  @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());
  }