@Test(dependsOnMethods = "testSubmitEntity")
  public void testAddProperty() throws Exception {
    final String guid = tableId._getId();
    // add property
    String description = "bar table - new desc";
    ClientResponse clientResponse = addProperty(guid, "description", description);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode());

    String entityRef = getEntityDefinition(getEntityDefinition(guid));
    Assert.assertNotNull(entityRef);

    tableInstance.set("description", description);

    // invalid property for the type
    clientResponse = addProperty(guid, "invalid_property", "bar table");
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());

    // non-string property, update
    String currentTime = String.valueOf(System.currentTimeMillis());
    clientResponse = addProperty(guid, "createTime", currentTime);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode());

    entityRef = getEntityDefinition(getEntityDefinition(guid));
    Assert.assertNotNull(entityRef);

    tableInstance.set("createTime", currentTime);
  }
Beispiel #2
0
  public <T> T putWor(
      String url,
      String resourcePath,
      Object object,
      Class<T> responseClass,
      Map<String, Object> queryParams,
      String worToken) {
    WebTarget target = client.target("https://" + url).path(resourcePath);
    if (queryParams != null) {
      for (Map.Entry<String, Object> entry : queryParams.entrySet()) {
        target = target.queryParam(entry.getKey(), entry.getValue());
      }
    }

    Invocation.Builder invocationBuilder = target.request(MediaType.APPLICATION_JSON_TYPE);
    setHeaders(invocationBuilder, worToken);
    Response putResponse =
        invocationBuilder.put(Entity.entity(object, MediaType.APPLICATION_JSON_TYPE));
    if (putResponse.getStatus() != Response.Status.OK.getStatusCode()) {
      Logger.error(
          "PUT call to "
              + url
              + "/"
              + resourcePath
              + " returned status of "
              + putResponse.getStatus());
      return null;
    }

    if (responseClass != null
        && putResponse.hasEntity()
        && putResponse.getStatus() == Response.Status.OK.getStatusCode())
      return putResponse.readEntity(responseClass);
    return null;
  }
  @Test(
      groups = {"wso2.greg", "wso2.greg.es"},
      description = "Adding subscription to a policy LC state change",
      dependsOnMethods = {"createPolicyAssetWithLC"})
  public void addSubscriptionForLCStateChange() throws JSONException, IOException {

    JSONObject dataObject = new JSONObject();

    dataObject.put("notificationType", "PublisherLifeCycleStateChanged");
    dataObject.put("notificationMethod", "work");

    ClientResponse response =
        genericRestClient.geneticRestRequestPost(
            publisherUrl + "/subscriptions/policy/" + assetId,
            MediaType.APPLICATION_JSON,
            MediaType.APPLICATION_JSON,
            dataObject.toString(),
            queryParamMap,
            headerMap,
            cookieHeader);

    assertTrue(
        (response.getStatusCode() == Response.Status.OK.getStatusCode()),
        "Wrong status code ,Expected"
            + Response.Status.OK.getStatusCode()
            + "Created ,Received "
            + response.getStatusCode());
  }
Beispiel #4
0
  @Test
  public void shouldFilterLogEntriesOnEventId() throws Exception {
    DocumentModel doc = RestServerInit.getFile(1, session);

    MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl();
    queryParams.putSingle("eventId", "documentModified");
    ClientResponse response =
        getResponse(
            BaseTest.RequestType.GET, "id/" + doc.getId() + "/@" + AuditAdapter.NAME, queryParams);

    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
    JsonNode node = mapper.readTree(response.getEntityInputStream());
    List<JsonNode> nodes = getLogEntries(node);
    assertEquals(1, nodes.size());
    assertEquals("documentModified", nodes.get(0).get("eventId").getValueAsText());

    queryParams.putSingle("principalName", "bender");
    response =
        getResponse(
            BaseTest.RequestType.GET, "id/" + doc.getId() + "/@" + AuditAdapter.NAME, queryParams);
    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
    node = mapper.readTree(response.getEntityInputStream());
    nodes = getLogEntries(node);
    assertEquals(0, nodes.size());
  }
 public String getSting(String uri) throws BeeterClientException {
   WebTarget target = client.target(uri);
   Response response = target.request().get();
   if (response.getStatus() == Response.Status.OK.getStatusCode())
     return response.readEntity(String.class);
   else throw new BeeterClientException(response.readEntity(String.class));
 }
  public String uploadImage(Part file) throws IOException {
    String imageURL = null;
    final Client client = ClientBuilder.newBuilder().register(MultiPartFeature.class).build();
    final StreamDataBodyPart stream = new StreamDataBodyPart("file", file.getInputStream());
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    final MultiPart multiPart =
        formDataMultiPart.field("fileName", file.getSubmittedFileName()).bodyPart(stream);
    if (multiPart instanceof FormDataMultiPart) {
      final FormDataMultiPart dataMultiPart = (FormDataMultiPart) multiPart;
      final WebTarget target = client.target(configuration.getFileUploadServiceEP());
      LOGGER.info("Connecting to file service on " + configuration.getFileUploadServiceEP());
      final Response response =
          target
              .request()
              .header(LoginBean.X_JWT_ASSERTION, getJWTToken())
              .post(Entity.entity(dataMultiPart, dataMultiPart.getMediaType()));
      LOGGER.info("Returned from file service " + configuration.getFileUploadServiceEP());
      if (Response.Status.OK.getStatusCode() == response.getStatus()) {
        imageURL = response.readEntity(String.class);
      } else {
        LOGGER.log(
            Level.SEVERE,
            "TXN service return code is  "
                + response.getStatus()
                + " , "
                + "hence can't proceed with the response");
      }
      formDataMultiPart.close();
      dataMultiPart.close();
      return imageURL;
    }

    return imageURL;
  }
  @Test
  public void testGetDownloadsShouldReturnOkResponse() throws Exception {
    doReturn("id").when(mockFacade).getDownloadIdInProgress();

    Response response = service.getDownloads();
    assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
  }
  @Test
  public void testGetStoragePropertiesShouldReturnOkResponse() throws Exception {
    doReturn(Collections.emptyMap()).when(mockFacade).loadStorageProperties();

    Response response = service.getArtifactProperties("codenvy", "3.1.0");
    assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
  }
  @Test
  public void testGetNodeConfigForMultiNode() throws IOException {
    Config testConfig =
        new Config(
            new LinkedHashMap<>(
                ImmutableMap.of(
                    "builder_host_name", "builder1.dev.com",
                    "additional_runners",
                        "http://runner1.dev.com:8080/runner/internal/runner,http://runner2.dev.com:8080/runner/internal/runner",
                    "analytics_host_name", "analytics.dev.com",
                    "additional_builders", "",
                    "host_url", "local.dev.com")));
    doReturn(testConfig).when(configManager).loadInstalledCodenvyConfig(InstallType.MULTI_SERVER);
    doReturn(InstallType.MULTI_SERVER).when(configManager).detectInstallationType();

    Response result = service.getNodesList();
    assertEquals(result.getStatus(), Response.Status.OK.getStatusCode());
    assertEquals(
        result.getEntity(),
        "{\n"
            + "  \"host_url\" : \"local.dev.com\",\n"
            + "  \"builder_host_name\" : \"builder1.dev.com\",\n"
            + "  \"additional_builders\" : [ ],\n"
            + "  \"analytics_host_name\" : \"analytics.dev.com\",\n"
            + "  \"additional_runners\" : [ \"runner1.dev.com\", \"runner2.dev.com\" ]\n"
            + "}");
  }
  @Test
  public void testGetConfig() throws Exception {
    doReturn(Collections.emptyMap()).when(mockFacade).getInstallationManagerProperties();

    Response response = service.getInstallationManagerServerConfig();
    assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
  }
  @Test
  public void testGetUpdatesShouldReturnOkStatus() throws Exception {
    doReturn(Collections.emptyList()).when(mockFacade).getAllUpdates(any(Artifact.class));

    Response result = service.getUpdates();
    assertEquals(result.getStatus(), Response.Status.OK.getStatusCode());
  }
Beispiel #12
0
  /**
   * Send an HTTP message to a worker and get the result
   *
   * <p>Note: expects the worker to respond with OK (200) status code.
   *
   * @param uriRequest The request to make
   * @return An InputStream of the response content
   */
  private InputStream askWorker(HttpUriRequest uriRequest) {
    try {
      HttpResponse response = httpClient.execute(uriRequest);

      if (response.getStatusLine().getStatusCode() != Response.Status.OK.getStatusCode()) {
        StatusLine statusLine = response.getStatusLine();
        EntityUtils.consume(response.getEntity());
        logger.warn(
            "Problem asking worker <"
                + metadata.getWorkerId()
                + "> "
                + "("
                + uriRequest.getURI()
                + "), "
                + "reason ["
                + statusLine.getStatusCode()
                + ": "
                + statusLine.getReasonPhrase()
                + "]");
      }

      return response.getEntity().getContent();
    } catch (IOException e) {
      logger.warn("Unable to communicated with worker " + metadata.toString());
      throw Throwables.propagate(e);
    }
  }
  @Test
  public void testMetadataImportExport()
      throws PlatformInitializationException, IOException, PlatformImportException {
    List<MimeType> mimeTypeList = new ArrayList<MimeType>();
    mimeTypeList.add(new MimeType("Metadata", ".xmi"));

    File metadata = new File("test-res/dsw/testData/metadata.xmi");
    RepositoryFile repoMetadataFile =
        new RepositoryFile.Builder(metadata.getName()).folder(false).hidden(false).build();
    MetadataImportHandler metadataImportHandler =
        new MetadataImportHandler(
            mimeTypeList,
            (IPentahoMetadataDomainRepositoryImporter)
                PentahoSystem.get(IMetadataDomainRepository.class));
    RepositoryFileImportBundle bundle1 =
        new RepositoryFileImportBundle.Builder()
            .file(repoMetadataFile)
            .charSet("UTF-8")
            .input(new FileInputStream(metadata))
            .mime(".xmi")
            .withParam("domain-id", "SalesData")
            .build();
    metadataImportHandler.importFile(bundle1);

    final Response salesData = new DatasourceResource().doGetDSWFilesAsDownload("SalesData");
    Assert.assertEquals(salesData.getStatus(), Response.Status.OK.getStatusCode());
    Assert.assertNotNull(salesData.getMetadata());
    Assert.assertNotNull(salesData.getMetadata().getFirst("Content-Disposition"));
    Assert.assertEquals(
        salesData.getMetadata().getFirst("Content-Disposition").getClass(), String.class);
    Assert.assertTrue(
        ((String) salesData.getMetadata().getFirst("Content-Disposition")).endsWith(".xmi\""));
  }
 private void testPredictDiabetes(boolean skipDecoding)
     throws MLHttpClientException, JSONException {
   String payload = "[[1,89,66,23,94,28.1,0.167,21],[2,197,70,45,543,30.5,0.158,53]]";
   String url =
       skipDecoding
           ? "/api/models/" + modelId + "/predict?skipDecoding=true"
           : "/api/models/" + modelId + "/predict";
   response = mlHttpclient.doHttpPost(url, payload);
   assertEquals(
       "Unexpected response received",
       Response.Status.OK.getStatusCode(),
       response.getStatusLine().getStatusCode());
   String reply = mlHttpclient.getResponseAsString(response);
   JSONArray predictions = new JSONArray(reply);
   assertEquals(
       "Expected 2 predictions but received only " + predictions.length(),
       2,
       predictions.length());
   if (skipDecoding) {
     assertEquals(
         "Expected a double value but found " + predictions.get(0),
         true,
         predictions.get(0) instanceof Double);
     assertEquals(
         "Expected a double value but found " + predictions.get(1),
         true,
         predictions.get(1) instanceof Double);
   }
 }
 @Test
 public void callToTestResourceShouldReturnOK() {
   Response result = target.path("test").request().get();
   assertThat(result).isNotNull();
   assertThat(result.getStatus()).isEqualTo(Response.Status.OK.getStatusCode());
   assertThat(result.readEntity(String.class)).isEqualTo("Got it!");
 }
 /**
  * A test case for building a model with the given learning algorithm
  *
  * @param algorithmName Name of the learning algorithm
  * @param algorithmType Type of the learning algorithm
  * @throws MLHttpClientException
  * @throws IOException
  * @throws JSONException
  * @throws InterruptedException
  */
 private void buildModelWithLearningAlgorithm(String algorithmName, String algorithmType)
     throws MLHttpClientException, IOException, JSONException, InterruptedException {
   modelName =
       MLTestUtils.createModelWithConfigurations(
           algorithmName,
           algorithmType,
           MLIntegrationTestConstants.RESPONSE_ATTRIBUTE_DIABETES,
           MLIntegrationTestConstants.TRAIN_DATA_FRACTION,
           projectId,
           versionSetId,
           mlHttpclient);
   modelId = mlHttpclient.getModelId(modelName);
   response = mlHttpclient.doHttpPost("/api/models/" + modelId);
   assertEquals(
       "Unexpected response received",
       Response.Status.OK.getStatusCode(),
       response.getStatusLine().getStatusCode());
   response.close();
   // Waiting for model building to end
   boolean status =
       MLTestUtils.checkModelStatusCompleted(
           modelName, mlHttpclient, MLIntegrationTestConstants.THREAD_SLEEP_TIME_LARGE, 1000);
   // Checks whether model building completed successfully
   assertEquals("Model building did not complete successfully", true, status);
 }
  @Test(dependsOnMethods = "testSubmit")
  public void testGetTypeNames() throws Exception {
    WebResource resource = service.path("api/atlas/types");

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

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

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

    final JSONArray list = response.getJSONArray(AtlasClient.RESULTS);
    Assert.assertNotNull(list);

    // Verify that primitive and core types are not returned
    String typesString = list.join(" ");
    Assert.assertFalse(typesString.contains(" \"__IdType\" "));
    Assert.assertFalse(typesString.contains(" \"string\" "));
  }
Beispiel #18
0
  @WebMethod
  @GET
  @Produces("application/json")
  @Path("/reports")
  public Response getReports(
      @QueryParam("aggregatorId") String aggregatorId,
      @QueryParam("providerId") String providerId,
      @QueryParam("productClass") String productClass)
      throws Exception {

    // Check basic permissions
    RSUser user = this.userManager.getCurrentUser();
    String effectiveAggregator;

    if (userManager.isAdmin()) {
      effectiveAggregator = aggregatorId;
    } else if (null == aggregatorId || aggregatorId.equals(user.getEmail())) {
      effectiveAggregator = user.getEmail();
    } else {
      String[] args = {"You are not allowed to retrieve report files for the given parameters"};
      throw new RSSException(UNICAExceptionType.NON_ALLOWED_OPERATION, args);
    }

    List<RSSReport> files =
        settlementManager.getSharingReports(effectiveAggregator, providerId, productClass);
    Response.ResponseBuilder rb = Response.status(Response.Status.OK.getStatusCode());
    rb.entity(files);
    return rb.build();
  }
  @Test(dependsOnMethods = "testSubmit")
  public void testGetDefinition() throws Exception {
    for (HierarchicalTypeDefinition typeDefinition : typeDefinitions) {
      System.out.println("typeName = " + typeDefinition.typeName);

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

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

      String responseAsString = clientResponse.getEntity(String.class);
      Assert.assertNotNull(responseAsString);
      JSONObject response = new JSONObject(responseAsString);
      Assert.assertNotNull(response.get(AtlasClient.DEFINITION));
      Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));

      String typesJson = response.getString(AtlasClient.DEFINITION);
      final TypesDef typesDef = TypesSerialization.fromJson(typesJson);
      List<HierarchicalTypeDefinition<ClassType>> hierarchicalTypeDefinitions =
          typesDef.classTypesAsJavaList();
      for (HierarchicalTypeDefinition<ClassType> classType : hierarchicalTypeDefinitions) {
        for (AttributeDefinition attrDef : classType.attributeDefinitions) {
          if ("name".equals(attrDef.name)) {
            assertEquals(attrDef.isIndexable, true);
            assertEquals(attrDef.isUnique, true);
          }
        }
      }
    }
  }
 public String execute(
     HttpServletRequest request, HttpServletResponse response, WebClient client) {
   log.debug("Update person");
   String result = "/searchPerson.jsp";
   String firstName = (String) request.getParameter("name");
   String lastName = (String) request.getParameter("surname");
   String date = (String) request.getParameter("date");
   String login = (String) request.getParameter("log");
   String email = (String) request.getParameter("mail");
   Person person = new Person(firstName, lastName, date);
   person.setLogin(login);
   person.setEmail(email);
   int i = client.path("/PersonService/updatePerson").put(person).getStatus();
   client.reset();
   if (i == Response.Status.OK.getStatusCode()) {
     request.setAttribute("person", person);
     return result;
   }
   if (i == Response.Status.NOT_FOUND.getStatusCode()) {
     log.debug("Person with login " + person.getLogin() + " not found");
     request.setAttribute("error", "Person with login " + person.getLogin() + " not found");
     result = "/error.jsp";
   }
   if (i == Response.Status.CONFLICT.getStatusCode()) {
     log.debug("Error occured while updating person");
     request.setAttribute("error", "Error occured while updating person");
     result = "/error.jsp";
   }
   return result;
 }
Beispiel #21
0
 public boolean delete(String token, String url, String resourcePath) {
   WebTarget target = client.target("https://" + url).path(resourcePath);
   Invocation.Builder invocationBuilder = target.request(MediaType.APPLICATION_JSON_TYPE);
   setHeaders(invocationBuilder, token);
   Response response = invocationBuilder.delete();
   return response.getStatus() == Response.Status.OK.getStatusCode();
 }
  @Test(
      groups = {"wso2.greg", "wso2.greg.es"},
      description = "Adding ratings added using rest api")
  public void addRatings() throws JSONException, IOException, InterruptedException {

    queryParamMap.clear();

    queryParamMap.put("path", path);
    queryParamMap.put("value", "4");

    ClientResponse response =
        genericRestClient.geneticRestRequestPost(
            registryAPIUrl + generalPath + "rate",
            MediaType.APPLICATION_JSON,
            MediaType.APPLICATION_JSON,
            null,
            queryParamMap,
            headerMap,
            sessionCookie);

    assertTrue(
        (response.getStatusCode() == Response.Status.OK.getStatusCode()),
        "Wrong status code ,Expected 200 OK ,Received " + response.getStatusCode());

    assertTrue(response.getEntity(String.class).equals("4.0"));
  }
  @Test
  public void succeedsToListByName() throws Throwable {
    VirtualSubnet expectedVirtualSubnet = new VirtualSubnet();
    expectedVirtualSubnet.setId(UUID.randomUUID().toString());
    expectedVirtualSubnet.setName("virtualNetwork");

    when(frontendClient.list(
            projectId, Project.KIND, Optional.of("virtualNetwork"), Optional.of(1)))
        .thenReturn(new ResourceList<>(ImmutableList.of(expectedVirtualSubnet)));

    Response response =
        listNetworks(Optional.of("virtualNetwork"), Optional.of(1), Optional.absent());
    assertThat(response.getStatus(), is(Response.Status.OK.getStatusCode()));

    ResourceList<VirtualSubnet> virtualNetworks =
        response.readEntity(new GenericType<ResourceList<VirtualSubnet>>() {});
    assertThat(virtualNetworks.getItems().size(), is(1));

    VirtualSubnet actualVirtualSubnet = virtualNetworks.getItems().get(0);
    assertThat(actualVirtualSubnet, is(expectedVirtualSubnet));

    String apiRoutePath =
        UriBuilder.fromPath(SubnetResourceRoutes.SUBNET_PATH)
            .build(expectedVirtualSubnet.getId())
            .toString();
    assertThat(actualVirtualSubnet.getSelfLink().endsWith(apiRoutePath), is(true));
    assertThat(new URI(actualVirtualSubnet.getSelfLink()).isAbsolute(), is(true));
  }
Beispiel #24
0
  @Test
  public void testGetCommand_ReturnsResponseContainingCommandStateDtoOfSpecifiedJob() {
    // Setup
    Integer jobId = 1;
    CommandJob job = createCommandJob(jobId, createImportCommand(), new Date(1l));
    CommandJobService mockCommandJobService = createMock(CommandJobService.class);
    expect(mockCommandJobService.getCommand(jobId)).andReturn(job).atLeastOnce();

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

    replay(mockCommandJobService);

    // Exercise
    Response response = sut.getCommand(jobId);

    // Verify mocks
    verify(mockCommandJobService);

    // Verify that the HTTP response code was OK (200) and that the body contains
    // the CommandStateDto of the specified task.
    assertThat(response).isNotNull();
    assertThat(response.getStatus()).isEqualTo(Response.Status.OK.getStatusCode());
    assertThat(response.getEntity()).isNotNull();
    assertThat(containsDtoForJob(response, job)).isTrue();
  }
Beispiel #25
0
 @Test
 public void testPing() throws Exception {
   WebClient client = WebClient.create(endpointUrl + "/hello/echo/SierraTangoNevada");
   Response r = client.accept("text/plain").get();
   assertEquals(Response.Status.OK.getStatusCode(), r.getStatus());
   String value = IOUtils.toString((InputStream) r.getEntity());
   assertEquals("SierraTangoNevada", value);
 }
 @Test
 public void testGetAccount() {
   Client client = ClientBuilder.newClient();
   WebTarget target =
       client.target("http://localhost:8080/employee-manager-container/rest/account/");
   Response response = target.request(MediaType.APPLICATION_JSON).get();
   assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
 }
Beispiel #27
0
  @Test
  public void shouldFilterLogEntriesOnEventCategories() throws Exception {
    DocumentModel doc = RestServerInit.getFile(1, session);

    List<LogEntry> logEntries = new ArrayList<>();
    LogEntry logEntry = auditLogger.newLogEntry();
    logEntry.setDocUUID(doc.getRef());
    logEntry.setCategory("One");
    logEntry.setEventId("firstEvent");
    logEntries.add(logEntry);
    logEntry = auditLogger.newLogEntry();
    logEntry.setDocUUID(doc.getRef());
    logEntry.setCategory("One");
    logEntry.setEventId("secondEvent");
    logEntries.add(logEntry);
    logEntry = auditLogger.newLogEntry();
    logEntry.setDocUUID(doc.getRef());
    logEntry.setCategory("Two");
    logEntry.setEventId("firstEvent");
    logEntries.add(logEntry);
    auditLogger.addLogEntries(logEntries);

    TransactionHelper.commitOrRollbackTransaction();
    TransactionHelper.startTransaction();

    MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl();
    queryParams.add("category", "One");
    queryParams.add("category", "Two");
    ClientResponse response =
        getResponse(
            BaseTest.RequestType.GET, "id/" + doc.getId() + "/@" + AuditAdapter.NAME, queryParams);
    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
    JsonNode node = mapper.readTree(response.getEntityInputStream());
    List<JsonNode> nodes = getLogEntries(node);
    assertEquals(3, nodes.size());

    queryParams = new MultivaluedMapImpl();
    queryParams.add("category", "Two");
    response =
        getResponse(
            BaseTest.RequestType.GET, "id/" + doc.getId() + "/@" + AuditAdapter.NAME, queryParams);
    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
    node = mapper.readTree(response.getEntityInputStream());
    nodes = getLogEntries(node);
    assertEquals(1, nodes.size());
  }
  private String getEntityDefinition(ClientResponse clientResponse) throws Exception {
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode());
    JSONObject response = new JSONObject(clientResponse.getEntity(String.class));
    final String definition = response.getString(AtlasClient.DEFINITION);
    Assert.assertNotNull(definition);

    return definition;
  }
  @Test
  public void testDeleteDomainFile() {
    WebResource resource = resource();
    ClientResponse response =
        resource.path("testClientId").path("target").path("problem").delete(ClientResponse.class);

    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
  }
Beispiel #30
0
  private void resetRepo() {
    Client client = ClientBuilder.newClient();
    WebTarget target = client.target(rootURI + "/airplanes/default");

    Response response = target.request(MediaType.APPLICATION_JSON).get();
    Assert.assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());

    response.close();
  }