/**
   * 20141022.
   *
   * @param jObj the j obj
   * @param projectionStr the projection str
   * @return the FQDN value list cms
   * @throws JSONException the JSON exception
   */
  static List<String> getFQDNValueListCMS(JSONObject jObj, String projectionStr)
      throws JSONException {
    final List<String> labelList = new ArrayList<String>();

    if (!jObj.has("result")) {
      logger.error(
          "!!CMS_ERROR! result key is not in jOBJ in getFQDNValueListCMS!!: \njObj:"
              + PcStringUtils.renderJson(jObj));

      return labelList;
    }
    JSONArray jArr = (JSONArray) jObj.get("result");
    if (jArr == null || jArr.length() == 0) {
      return labelList;
    }
    for (int i = 0; i < jArr.length(); ++i) {
      JSONObject agentObj = jArr.getJSONObject(i);
      // properties can be null

      if (!agentObj.has(projectionStr)) {
        continue;
      }
      String label = (String) agentObj.get(projectionStr);

      if (label != null && !label.trim().isEmpty()) {
        labelList.add(label);
      }
    }

    return labelList;
  }
Пример #2
0
    @SuppressWarnings("unchecked")
    public static void assertEquals(@NotNull JSONObject expected, @NotNull JSONObject target)
        throws JSONException {

      for (Iterator<String> iterator = expected.keys(); iterator.hasNext(); ) {
        String key = iterator.next();

        // match the key names
        assertThat(target.get(key)).isNotNull();

        Object expectedValue = expected.get(key);
        Object targetValue = target.get(key);

        // match the value class types
        assertThat(expectedValue).isInstanceOf(targetValue.getClass());

        if (expectedValue instanceof JSONObject) {
          // For now, recurse only the JSON object
          assertThat(expected.getJSONObject(key)).isEqualTo(target.getJSONObject(key));
        } else if (expectedValue instanceof JSONArray) {
          // TODO handle JSONArray in the future
          Assert.fail();
        } else {
          // compare values
          assertThat(expectedValue).isEqualTo(targetValue);
        }
      }
    }
Пример #3
0
  @POST
  @Consumes(MediaType.APPLICATION_JSON)
  public Response saveListItem(InputStream incomingData) {
    StringBuilder listBuilder = new StringBuilder();
    try {
      BufferedReader in = new BufferedReader(new InputStreamReader(incomingData));
      String line = null;
      while ((line = in.readLine()) != null) {
        listBuilder.append(line);
      }
    } catch (Exception e) {
      System.out.println("Error Parsing: - ");
    }

    try {
      JSONObject json = new JSONObject(listBuilder.toString());
      Iterator<String> iterator = json.keys();
      if (list == null) {
        list = new ArrayList<ListItem>();
      }
      ListItem item =
          new ListItem(
              (String) json.get(iterator.next()),
              (String) json.get(iterator.next()),
              (Boolean) json.get(iterator.next()));
      list.add(item);
    } catch (JSONException e) {
      e.printStackTrace();
      return Response.status(500).entity(listBuilder.toString()).build();
    }
    // return HTTP response 200 in case of success
    return Response.status(200).entity(listBuilder.toString()).build();
  }
Пример #4
0
  @Test
  public void shouldRespectQueryOffsetAndLimit() throws Exception {
    final String NODE_PATH = "nodeForOffsetAndLimitTest";

    createNode("/" + NODE_PATH, 1);
    createNode("/" + NODE_PATH, 2);
    createNode("/" + NODE_PATH, 3);
    createNode("/" + NODE_PATH, 4);

    URL queryUrl = new URL(SERVER_URL + "/mode%3arepository/default/query?offset=1&limit=2");
    HttpURLConnection connection = (HttpURLConnection) queryUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", "application/jcr+xpath");

    String payload = "//element(" + NODE_PATH + ") order by @foo";

    connection.getOutputStream().write(payload.getBytes());
    JSONObject queryResult = new JSONObject(getResponseFor(connection));
    JSONArray results = (JSONArray) queryResult.get("rows");

    assertThat(results.length(), is(2));

    JSONObject result = (JSONObject) results.get(0);
    assertThat(result, is(notNullValue()));
    assertThat((String) result.get("jcr:path"), is("/" + NODE_PATH + "[2]"));

    result = (JSONObject) results.get(1);
    assertThat(result, is(notNullValue()));
    assertThat((String) result.get("jcr:path"), is("/" + NODE_PATH + "[3]"));
  }
  @Test
  public void testDeleteTraitNonExistent() throws Exception {
    final String traitName = "blah_trait";

    ClientResponse clientResponse =
        service
            .path(ENTITIES)
            .path("random")
            .path(TRAITS)
            .path(traitName)
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(HttpMethod.DELETE, ClientResponse.class);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.NOT_FOUND.getStatusCode());

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

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.ERROR));
    Assert.assertEquals(
        response.getString(AtlasClient.ERROR),
        "trait=" + traitName + " should be defined in type system before it can be deleted");
    Assert.assertNotNull(response.get(AtlasClient.STACKTRACE));
  }
Пример #6
0
  @Test
  public void updateUser() {
    boolean thrown = false;
    WebResource webResource = resource();

    try {
      JSONObject user =
          webResource
              .path("resources/users/testuid")
              .accept("application/json")
              .get(JSONObject.class);

      user.put("password", "NEW PASSWORD")
          .put("email", "*****@*****.**")
          .put("username", "UPDATED TEST USER");
      webResource.path("resources/users/testuid").type("application/json").put(user);

      user =
          webResource
              .path("resources/users/testuid")
              .accept("application/json")
              .get(JSONObject.class);

      assertEquals(user.get("username"), "UPDATED TEST USER");
      assertEquals(user.get("email"), "*****@*****.**");
      assertEquals(user.get("password"), "NEW PASSWORD");

    } catch (Exception e) {
      e.printStackTrace();
      thrown = true;
    }

    assertFalse(thrown);
  }
 private boolean hasOrAndOperator(JSONObject jsonCriteria) throws JSONException {
   if (!jsonCriteria.has(OPERATOR_KEY)) {
     return mainOperatorIsAnd;
   }
   return OPERATOR_OR.equals(jsonCriteria.get(OPERATOR_KEY))
       || OPERATOR_AND.equals(jsonCriteria.get(OPERATOR_KEY));
 }
Пример #8
0
  @PUT
  @Consumes(MediaType.APPLICATION_JSON)
  public Response addUpdateListItem(InputStream incomingData) {
    StringBuilder listBuilder = new StringBuilder();
    try {
      BufferedReader in = new BufferedReader(new InputStreamReader(incomingData));
      String line = null;
      while ((line = in.readLine()) != null) {
        listBuilder.append(line);
      }
    } catch (Exception e) {
      System.out.println("Error Parsing :- ");
    }

    try {
      JSONObject json = new JSONObject(listBuilder.toString());
      Iterator<String> iterator = json.keys();
      ListItem item =
          new ListItem(
              (String) json.get(iterator.next()),
              (String) json.get(iterator.next()),
              Boolean.parseBoolean((String) json.get(iterator.next())));
      int index = list.indexOf(item);
      item = list.get(index);
      list.remove(index);
      item.setTitle((String) json.get(iterator.next()));
      item.setBody((String) json.get(iterator.next()));
      list.add(index, item);
    } catch (JSONException e) {
      e.printStackTrace();
    }
    // return HTTP response 200 in case of success
    return Response.status(200).entity(listBuilder.toString()).build();
  }
  @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));
  }
Пример #10
0
  @Test
  public void shouldRetrieveDataFromXPathQuery() throws Exception {
    final String NODE_PATH = "/nodeForQuery";
    URL postUrl = new URL(SERVER_URL + "/mode%3arepository/default/items" + NODE_PATH);
    HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_JSON);

    String payload = "{ \"properties\": {\"jcr:primaryType\": \"nt:unstructured\" }}";
    connection.getOutputStream().write(payload.getBytes());

    assertThat(connection.getResponseCode(), is(HttpURLConnection.HTTP_CREATED));
    connection.disconnect();

    URL queryUrl = new URL(SERVER_URL + "/mode%3arepository/default/query");
    connection = (HttpURLConnection) queryUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", "application/jcr+xpath");

    payload = "//nodeForQuery";
    connection.getOutputStream().write(payload.getBytes());
    JSONObject queryResult = new JSONObject(getResponseFor(connection));
    JSONArray results = (JSONArray) queryResult.get("rows");

    assertThat(results.length(), is(1));

    JSONObject result = (JSONObject) results.get(0);
    assertThat(result, is(notNullValue()));
    assertThat((String) result.get("jcr:path"), is(NODE_PATH));
    assertThat((String) result.get("jcr:primaryType"), is("nt:unstructured"));
  }
Пример #11
0
 @Test
 public void test() throws JSONException {
   Map<String, String> map = new HashMap<String, String>();
   map.put("serviceurl", "http:/");
   JSONObject jo = new JSONObject(map);
   System.out.println(jo.get("serviceurl"));
   assertEquals("http:/", jo.get("serviceurl"));
   System.out.println((DBObject) JSON.parse(jo.toString()));
 }
Пример #12
0
 @Test
 public void getAttribute() throws JSONException {
   JSONObject jo =
       r.path(MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN + "/MyAttr")
           .accept("application/json")
           .get(JSONObject.class);
   assertEquals(
       "Not correct mbean name", jo.get("name"), MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN);
   assertEquals("Not correct attribute" + jo, "MyAttr", jo.get("attribute"));
   assertEquals("Not correct attribute value " + jo, MBeanServerSetup.DEFAULT, jo.get("value"));
 }
 private boolean parseBetween(JSONObject jsonCriteria, String operator, boolean inclusive)
     throws JSONException {
   final String fieldName = jsonCriteria.getString(FIELD_NAME_KEY);
   final Object start = jsonCriteria.get("start");
   final Object end = jsonCriteria.get("end");
   final boolean leftClause =
       parseSimpleClause(fieldName, getBetweenOperator(operator, false), start);
   final boolean rightClause =
       parseSimpleClause(fieldName, getBetweenOperator(operator, true), end);
   return leftClause && rightClause;
 }
Пример #14
0
 @Test
 public void getBooleanAttribute() throws JSONException {
   r.path(MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN + "/So")
       .type("text/plain")
       .put(JSONObject.class, "false");
   JSONObject jo =
       r.path(MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN + "/So")
           .accept("application/json")
           .get(JSONObject.class);
   assertEquals(
       "Not correct mbean name", jo.get("name"), MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN);
   assertEquals("Not correct attribute" + jo, "So", jo.get("attribute"));
   assertEquals("Not correct attribute value " + jo, false, jo.get("value"));
 }
  @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");
  }
Пример #16
0
  @Test
  public void shouldRetrieveRootNodeForValidRepository() throws Exception {
    URL postUrl = new URL(SERVER_URL + "/mode%3arepository/default/items/");
    HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_JSON);

    JSONObject body = new JSONObject(getResponseFor(connection));
    assertThat(body.length(), is(2));

    JSONObject properties = body.getJSONObject("properties");
    assertThat(properties, is(notNullValue()));
    assertThat(properties.length(), is(2));
    assertThat(properties.getString("jcr:primaryType"), is("mode:root"));
    assertThat(properties.get("jcr:uuid"), is(notNullValue()));

    JSONArray children = body.getJSONArray("children");
    assertThat(children.length(), is(1));
    assertThat(children.getString(0), is("jcr:system"));

    assertThat(connection.getResponseCode(), is(HttpURLConnection.HTTP_OK));
    connection.disconnect();
  }
Пример #17
0
  // @FixFor( "MODE-886" )
  @Test
  public void shouldAllowJcrSql2Query() throws Exception {
    final String NODE_PATH = "nodeForJcrSql2QueryTest";

    createNode("/" + NODE_PATH, 1);

    createNode("/" + NODE_PATH + "/child", 1);
    createNode("/" + NODE_PATH + "/child", 2);
    createNode("/" + NODE_PATH + "/child", 3);
    createNode("/" + NODE_PATH + "/child", 4);

    URL queryUrl = new URL(SERVER_URL + "/mode%3arepository/default/query");
    HttpURLConnection connection = (HttpURLConnection) queryUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", "application/jcr+sql2");

    String payload = "SELECT * FROM [nt:unstructured] WHERE ISCHILDNODE('/" + NODE_PATH + "')";

    connection.getOutputStream().write(payload.getBytes());
    JSONObject queryResult = new JSONObject(getResponseFor(connection));
    JSONArray results = (JSONArray) queryResult.get("rows");

    assertThat(results.length(), is(4));
  }
  @Test
  public void useAuthorizationCodeWithoutScopesTest() throws InterruptedException, JSONException {
    String currentUrl =
        OauthAuthorizationPageHelper.loginAndAuthorize(
            this.getWebBaseUrl(),
            this.getClient1ClientId(),
            this.getClient1RedirectUri(),
            ScopePathType.ORCID_WORKS_CREATE.value(),
            null,
            this.getUser1UserName(),
            this.getUser1Password(),
            true,
            webDriver);
    Matcher matcher = AUTHORIZATION_CODE_PATTERN.matcher(currentUrl);
    assertTrue(matcher.find());
    String authorizationCode = matcher.group(1);
    assertFalse(PojoUtil.isEmpty(authorizationCode));

    ClientResponse tokenResponse =
        getClientResponse(
            this.getClient1ClientId(),
            this.getClient1ClientSecret(),
            null,
            this.getClient1RedirectUri(),
            authorizationCode);
    assertEquals(200, tokenResponse.getStatus());
    String body = tokenResponse.getEntity(String.class);
    JSONObject jsonObject = new JSONObject(body);
    String accessToken = (String) jsonObject.get("access_token");
    assertNotNull(accessToken);
    assertFalse(PojoUtil.isEmpty(accessToken));
  }
  /**
   * Login to the PAScoresDwnld site. This method has not been modified from the original published
   * by CollegeBoard.
   *
   * <p>For more information, please see: <a href=
   * "https://collegereadiness.collegeboard.org/educators/higher-ed/reporting-portal-help#features">
   * https://collegereadiness.collegeboard.org/educators/higher-ed/reporting-
   * portal-help#features</a>
   *
   * <p>Original code can be accessed at: <a href=
   * "https://collegereadiness.collegeboard.org/zip/pascoredwnld-java-sample.zip">
   * https://collegereadiness.collegeboard.org/zip/pascoredwnld-java-sample.zip </a>
   *
   * @author CollegeBoard
   * @param username Username to login with
   * @param password Password to login with
   * @return Authentication token
   */
  private String login(String username, String password) {
    Client client = getClient();
    WebResource webResource = client.resource(scoredwnldUrlRoot + "/pascoredwnld/login");

    String input = "{\"username\":\"" + username + "\",\"password\":\"" + password + "\"};";

    ClientResponse response =
        webResource
            .accept("application/json")
            .type("application/json")
            .post(ClientResponse.class, input);

    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    try {
      JSONObject json = new JSONObject(response.getEntity(String.class));
      return String.valueOf(json.get("token"));
    } catch (Exception e) {
      log("Error: " + e.getMessage());
      e.printStackTrace();
    }
    return "";
  }
  /**
   * Get the URL of the file to download. This has not been modified from the original version.
   *
   * <p>For more information, please see: <a href=
   * "https://collegereadiness.collegeboard.org/educators/higher-ed/reporting-portal-help#features">
   * https://collegereadiness.collegeboard.org/educators/higher-ed/reporting-
   * portal-help#features</a>
   *
   * <p>Original code can be accessed at: <a href=
   * "https://collegereadiness.collegeboard.org/zip/pascoredwnld-java-sample.zip">
   * https://collegereadiness.collegeboard.org/zip/pascoredwnld-java-sample.zip </a>
   *
   * @see #login(String, String)
   * @see org.collegeboard.scoredwnld.client.FileInfo
   * @author CollegeBoard
   * @param accessToken Access token obtained from {@link #login(String, String)}
   * @param filePath File to download
   * @return FileInfo descriptor of file to download
   */
  private FileInfo getFileUrlByToken(String accessToken, String filePath) {

    Client client = getClient();
    WebResource webResource =
        client.resource(
            scoredwnldUrlRoot + "/pascoredwnld/file?tok=" + accessToken + "&filename=" + filePath);
    ClientResponse response = webResource.accept("application/json").get(ClientResponse.class);
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    try {
      JSONObject json = new JSONObject(response.getEntity(String.class));
      FileInfo fileInfo = new FileInfo();
      fileInfo.setFileName(filePath);
      fileInfo.setFileUrl(String.valueOf(json.get("fileUrl")));
      return fileInfo;
    } catch (ClientHandlerException e) {
      log("Error: " + e.getMessage());
      e.printStackTrace();
    } catch (UniformInterfaceException e) {
      log("Error: " + e.getMessage());
      e.printStackTrace();
    } catch (JSONException e) {
      log("Error: " + e.getMessage());
      e.printStackTrace();
    }

    return null;
  }
Пример #21
0
 @Test
 public void getMBean() throws JSONException {
   JSONObject jo =
       r.path(MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN)
           .accept("application/json")
           .get(JSONObject.class);
   assertEquals(
       "Not correct mbean name", jo.get("name"), MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN);
   assertEquals(
       "Not correct attribute value " + jo,
       MBeanServerSetup.DEFAULT,
       jo.getJSONObject("attributes").getJSONObject("MyAttr").get("value"));
   boolean isWritable =
       ((Boolean) jo.getJSONObject("attributes").getJSONObject("MyAttr").get("writable"))
           .booleanValue();
   assertTrue("Attrubute should be writable " + jo, isWritable);
   JSONArray operations = jo.getJSONArray("operations");
   for (int i = 0; i < operations.length(); i++) {
     JSONObject op = operations.getJSONObject(i);
     if (op.getString("name").equals("simpleMethod")) {
       return;
     }
   }
   fail("Should contain simpleMethod " + jo);
 }
  @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));
    }
  }
Пример #23
0
  @Test
  public void shouldPostNodeToValidPathWithPrimaryType() throws Exception {
    URL postUrl = new URL(SERVER_URL + "/mode%3arepository/default/items/nodeA");
    HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();

    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", MediaType.APPLICATION_JSON);

    String payload =
        "{ \"properties\": {\"jcr:primaryType\": \"nt:unstructured\", \"testProperty\": \"testValue\", \"multiValuedProperty\": [\"value1\", \"value2\"]}}";
    connection.getOutputStream().write(payload.getBytes());

    JSONObject body = new JSONObject(getResponseFor(connection));
    assertThat(body.length(), is(1));

    JSONObject properties = body.getJSONObject("properties");
    assertThat(properties, is(notNullValue()));
    assertThat(properties.length(), is(3));
    assertThat(properties.getString("jcr:primaryType"), is("nt:unstructured"));
    assertThat(properties.getString("testProperty"), is("testValue"));
    assertThat(properties.get("multiValuedProperty"), instanceOf(JSONArray.class));

    JSONArray values = properties.getJSONArray("multiValuedProperty");
    assertThat(values, is(notNullValue()));
    assertThat(values.length(), is(2));
    assertThat(values.getString(0), is("value1"));
    assertThat(values.getString(1), is("value2"));

    assertThat(connection.getResponseCode(), is(HttpURLConnection.HTTP_CREATED));
    connection.disconnect();
  }
 private boolean parseStructuredClause(JSONArray clauses, String hqlOperator)
     throws JSONException {
   boolean doOr = OPERATOR_OR.equals(hqlOperator);
   boolean doAnd = OPERATOR_AND.equals(hqlOperator);
   for (int i = 0; i < clauses.length(); i++) {
     final JSONObject clause = clauses.getJSONObject(i);
     if (clause.has(VALUE_KEY)
         && clause.get(VALUE_KEY) != null
         && clause.getString(VALUE_KEY).equals("")) {
       continue;
     }
     final boolean clauseResult = parseCriteria(clause);
     if (doOr && clauseResult) {
       return true;
     }
     if (doAnd && !clauseResult) {
       return false;
     }
   }
   if (doOr) {
     return false;
   } else if (doAnd) {
     return true;
   }
   return mainOperatorIsAnd;
 }
  @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\" "));
  }
  @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);
          }
        }
      }
    }
  }
Пример #27
0
 @Test
 public void putIntAttribute() throws Exception {
   JSONObject jo =
       r.path(MBeanServerSetup.TESTDOMAIN_NAME_TEST_BEAN + "/MyIntAttr")
           .type("text/plain")
           .put(JSONObject.class, "10");
   assertEquals("Not correct attribute value " + jo, 10, jo.get("value"));
 }
 private String getFieldStringUnisex(JSONObject json, String attributeName) throws JSONException {
   final JSONObject fieldsJson = json.getJSONObject(FIELDS);
   final Object fieldJson = fieldsJson.get(attributeName);
   if (fieldJson instanceof JSONObject) {
     return ((JSONObject) fieldJson).getString(VALUE_ATTR); // pre 5.0 way
   }
   return fieldJson.toString(); // JIRA 5.0 way
 }
  @Test
  public void testGetInvalidEntityDefinition() throws Exception {
    WebResource resource = service.path(ENTITIES).path("blah");

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

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

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.ERROR));
    Assert.assertNotNull(response.get(AtlasClient.STACKTRACE));
  }
  @Test
  public void testGetEntityListForBadEntityType() throws Exception {
    ClientResponse clientResponse =
        service
            .path(ENTITIES)
            .queryParam("type", "blah")
            .accept(Servlets.JSON_MEDIA_TYPE)
            .type(Servlets.JSON_MEDIA_TYPE)
            .method(HttpMethod.GET, ClientResponse.class);
    Assert.assertEquals(clientResponse.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());

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

    JSONObject response = new JSONObject(responseAsString);
    Assert.assertNotNull(response.get(AtlasClient.ERROR));
    Assert.assertNotNull(response.get(AtlasClient.STACKTRACE));
  }