Exemplo n.º 1
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]"));
  }
 @Nullable
 private <T> Collection<T> parseOptionalArray(
     boolean shouldUseNestedValueJson,
     JSONObject json,
     JsonWeakParser<T> jsonParser,
     String... path)
     throws JSONException {
   if (shouldUseNestedValueJson) {
     final JSONObject js = JsonParseUtil.getNestedOptionalObject(json, path);
     if (js == null) {
       return null;
     }
     return parseArray(js, jsonParser, VALUE_ATTR);
   } else {
     final JSONArray jsonArray = JsonParseUtil.getNestedOptionalArray(json, path);
     if (jsonArray == null) {
       return null;
     }
     final Collection<T> res = new ArrayList<T>(jsonArray.length());
     for (int i = 0; i < jsonArray.length(); i++) {
       res.add(jsonParser.parse(jsonArray.get(i)));
     }
     return res;
   }
 }
Exemplo n.º 3
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"));
  }
Exemplo n.º 4
0
 public static JSONArray concatArray(JSONArray... arrs) throws JSONException {
   JSONArray result = new JSONArray();
   for (JSONArray arr : arrs) {
     for (int i = 0; i < arr.length(); i++) {
       result.put(arr.get(i));
     }
   }
   return result;
 }
 /**
  * Test Supplier Url filter Service Query option.
  *
  * @throws IOException
  * @throws JSONException
  */
 @Test
 public void testSupplierUrlFilter() throws IOException, JSONException {
   JSONObject jo;
   HttpResponse resp =
       RequestExecutionHelper.executeGetRequest(
           ENTITY_NAME
               + "?$format=json&$filter=EmailAddress%20eq%20'*****@*****.**'&$top=1",
           true);
   JSONArray ja = RequestExecutionHelper.getJSONArrayofResults(resp.getBody());
   assertNotNull("Unable to parse JSON response", ja);
   jo = (JSONObject) ja.get(0);
   assertEquals("Supplier not filtered Supplier Id", "100000045", jo.getString("SupplierId"));
 }
 /**
  * Test if Supplier URL Skip Service Query Option.
  *
  * @throws JSONException
  * @throws IOException
  */
 @Test
 public void testSupplierUrlSkip() throws JSONException, IOException {
   JSONObject jo;
   HttpResponse resp =
       RequestExecutionHelper.executeGetRequest(
           ENTITY_NAME + "?$format=json&$orderby=SupplierId&$skip=1", true);
   JSONArray ja = RequestExecutionHelper.getJSONArrayofResults(resp.getBody());
   assertNotNull("Unable to parse JSON response", ja);
   jo = (JSONObject) ja.get(0);
   assertEquals(
       "First Supplier in the ordered response not skipped",
       "100000042",
       jo.getString("SupplierId"));
 }
 /**
  * Test Supplier Url Top and Orderby Service Query option.
  *
  * @throws IOException
  * @throws JSONException
  */
 @Test
 public void testSupplierUrlTopOrderby() throws IOException, JSONException {
   JSONObject jo;
   HttpResponse resp =
       RequestExecutionHelper.executeGetRequest(
           ENTITY_NAME + "?$format=json&$orderby=SupplierId&$top=1", true);
   JSONArray ja = RequestExecutionHelper.getJSONArrayofResults(resp.getBody());
   assertNotNull("Unable to parse JSON response", ja);
   jo = (JSONObject) ja.get(0);
   assertEquals(
       "Suppliers not orderedby Supplier Id in ascending order",
       "100000041",
       jo.getString("SupplierId"));
 }
 private <T> Collection<T> parseArray(
     JSONObject jsonObject, JsonWeakParser<T> jsonParser, String arrayAttribute)
     throws JSONException {
   //        String type = jsonObject.getString("type");
   //        final String name = jsonObject.getString("name");
   final JSONArray valueObject = jsonObject.optJSONArray(arrayAttribute);
   if (valueObject == null) {
     return new ArrayList<T>();
   }
   Collection<T> res = new ArrayList<T>(valueObject.length());
   for (int i = 0; i < valueObject.length(); i++) {
     res.add(jsonParser.parse(valueObject.get(i)));
   }
   return res;
 }
  @Override
  public String execute(HttpServletRequest request) throws Exception {

    CourseClient cC = new CourseClient();
    ArrayList<String> names = new ArrayList<>();

    JSONArray courses = cC.findAll_JSON(JSONArray.class);
    for (int i = 0; i < courses.length(); i++) {
      JSONObject course = (JSONObject) courses.get(i);
      names.add(course.getString("name"));
    }

    Gson json = new Gson();
    String str = json.toJson(names);

    return str;
  }
 /**
  * Test if Supplier URL Select Service Query Option.
  *
  * @throws IOException
  * @throws JSONException
  */
 @Test
 public void testSupplierUrlSelect() throws IOException, JSONException {
   HttpResponse resp =
       RequestExecutionHelper.executeGetRequest(
           ENTITY_NAME
               + "?$format=json&$orderby=SupplierId&$skip=1&$top=1&$select=SupplierId,Country",
           true);
   JSONArray ja = RequestExecutionHelper.getJSONArrayofResults(resp.getBody());
   assertNotNull("Unable to parse JSON response", ja);
   ja.get(0);
   assertTrue(
       "Selected property Country does not exist in the odata service",
       resp.getBody().contains("Country"));
   assertTrue(
       "Non selected property City still exists in the odata service",
       !resp.getBody().contains("City"));
 }
  /**
   * Test Update Supplier via URL.
   *
   * @throws IOException
   * @throws JSONException
   */
  @Test
  public void testUpdateSupplierViaREST() throws IOException, JSONException {
    String supplierXml = StreamHelper.readFromFile(FILENAME);
    String newPhoneNumber = "111111";
    String email = rand.nextInt(200) + "@sap.com";
    supplierXml =
        supplierXml.replace(
            "<d:EmailAddress>email</d:EmailAddress>",
            "<d:EmailAddress>" + email + "</d:EmailAddress>");
    String id = RequestExecutionHelper.createEntityViaREST(ENTITY_NAME, supplierXml, true);
    HttpResponse resp =
        RequestExecutionHelper.executeGetRequest(
            ENTITY_NAME + "?$format=json&$filter=SupplierId%20eq%20'" + id + "'", true);
    assertEquals("Supplier not persisted", HttpURLConnection.HTTP_OK, resp.getResponseCode());

    supplierXml =
        supplierXml.replace(
            "<d:PhoneNumber>5899428367</d:PhoneNumber>",
            "<d:PhoneNumber>" + newPhoneNumber + "</d:PhoneNumber>");
    resp =
        RequestExecutionHelper.executePutRequest(ENTITY_NAME + "('" + id + "')", supplierXml, true);
    assertEquals(
        "Unable to update Supplier via URL Response Message:" + resp.getResponseMessage(),
        HttpURLConnection.HTTP_NO_CONTENT,
        resp.getResponseCode());
    resp =
        RequestExecutionHelper.executeGetRequest(
            ENTITY_NAME + "?$format=json&$filter=SupplierId%20eq%20'" + id + "'", true);
    JSONArray ja = RequestExecutionHelper.getJSONArrayofResults(resp.getBody());
    assertNotNull("Unable to parse JSON response", ja);
    JSONObject jo = (JSONObject) ja.get(0);
    assertEquals(
        "Updated Supplier via URL not persisted in db",
        newPhoneNumber,
        jo.getString("PhoneNumber"));
    resp = RequestExecutionHelper.executeDeleteRequest(ENTITY_NAME + "('" + id + "')", true);
    assertEquals(
        "Unable to delete Supplier via REST or incorrect HTTP Response Code:"
            + resp.getResponseMessage(),
        HttpURLConnection.HTTP_OK,
        resp.getResponseCode());
  }
Exemplo n.º 12
0
 public CompositeValueModel(JSONObject values) {
   try {
     Iterator<String> i = values.keys();
     while (i.hasNext()) {
       String childTypeUri = i.next();
       Object value = values.get(childTypeUri);
       if (value instanceof JSONArray) {
         JSONArray valueArray = (JSONArray) value;
         for (int j = 0; j < valueArray.length(); j++) {
           add(childTypeUri, createTopicModel(childTypeUri, valueArray.get(j)));
         }
       } else {
         put(childTypeUri, createTopicModel(childTypeUri, value));
       }
     }
   } catch (Exception e) {
     throw new RuntimeException(
         "Parsing CompositeValueModel failed (JSONObject=" + values + ")", e);
   }
 }
  @GET
  @Consumes(MediaType.APPLICATION_JSON)
  @Produces(MediaType.APPLICATION_JSON)
  @Path("identificateFiles/")
  public Response identificateFiles(@QueryParam("uuids") JSONArray uuids) {
    List<java.nio.file.Path> paths = new ArrayList<>();
    for (int i = 0; i < uuids.length(); i++) {
      try {
        String uuid = (String) uuids.get(i);
        paths.add(new File(System.getProperty("user.dir")).toPath().resolve("books").resolve(uuid));
      } catch (JSONException e) {
        return Response.serverError().build();
      }
    }
    IdentificateBooks idBooks = new IdentificateBooks(paths);

    IdentificationResult identificationResult = idBooks.startIdentification();
    logger.info(identificationResult.getResult());
    return Response.ok(identificationResult.getResult()).build();
  }
  private boolean parseSingleClause(JSONObject jsonCriteria) throws JSONException {
    String operator = jsonCriteria.getString(OPERATOR_KEY);

    if (operator.equals(OPERATOR_BETWEEN)
        || operator.equals(OPERATOR_BETWEENINCLUSIVE)
        || operator.equals(OPERATOR_IBETWEEN)
        || operator.equals(OPERATOR_IBETWEENINCLUSIVE)) {
      return parseBetween(jsonCriteria, operator, true);
    }

    Object value = jsonCriteria.has(VALUE_KEY) ? jsonCriteria.get(VALUE_KEY) : null;

    if (operator.equals(OPERATOR_EXISTS)) {
      // not supported
      return mainOperatorIsAnd;
    }

    String fieldName = jsonCriteria.getString(FIELD_NAME_KEY);

    // translate to a OR for each value
    if (value instanceof JSONArray) {
      final JSONArray jsonArray = (JSONArray) value;
      final JSONObject advancedCriteria = new JSONObject();
      advancedCriteria.put(OPERATOR_KEY, OPERATOR_OR);
      final JSONArray subCriteria = new JSONArray();
      for (int i = 0; i < jsonArray.length(); i++) {
        final JSONObject subCriterion = new JSONObject();
        subCriterion.put(OPERATOR_KEY, operator);
        subCriterion.put(FIELD_NAME_KEY, fieldName);
        subCriterion.put(VALUE_KEY, jsonArray.get(i));
        subCriteria.put(i, subCriterion);
      }
      advancedCriteria.put(CRITERIA_KEY, subCriteria);
      return parseAdvancedCriteria(advancedCriteria);
    }

    // Retrieves the UTC time zone offset of the client
    if (jsonCriteria.has("minutesTimezoneOffset")) {
      int clientMinutesTimezoneOffset =
          Integer.parseInt(jsonCriteria.get("minutesTimezoneOffset").toString());
      Calendar now = Calendar.getInstance();
      // Obtains the UTC time zone offset of the server
      int serverMinutesTimezoneOffset =
          (now.get(Calendar.ZONE_OFFSET) + now.get(Calendar.DST_OFFSET)) / (1000 * 60);
      // Obtains the time zone offset between the server and the client
      clientUTCMinutesTimeZoneDiff = clientMinutesTimezoneOffset;
      UTCServerMinutesTimeZoneDiff = serverMinutesTimezoneOffset;
    }

    if (operator.equals(OPERATOR_ISNULL) || operator.equals(OPERATOR_NOTNULL)) {
      value = null;
    }

    // if a comparison is done on an equal date then replace
    // with a between start time and end time on that date
    if (operator.equals(OPERATOR_EQUALS) || operator.equals(OPERATOR_EQUALSFIELD)) {
      Object curValue = recordMap.get(fieldName);
      if (curValue instanceof Date) {
        if (operator.equals(OPERATOR_EQUALS)) {
          return parseSimpleClause(fieldName, OPERATOR_GREATEROREQUAL, value)
              && parseSimpleClause(fieldName, OPERATOR_LESSOREQUAL, value);

        } else {
          return parseSimpleClause(fieldName, OPERATOR_GREATEROREQUALFIELD, value)
              && parseSimpleClause(fieldName, OPERATOR_LESSOREQUALFIElD, value);
        }
      }
    }

    return parseSimpleClause(fieldName, operator, value);
  }
  @Parameters({"redirectUris", "sectorIdentifierUri", "logoutUri"})
  @Test
  public void requestClientAssociate2(
      final String redirectUris, final String sectorIdentifierUri, final String logoutUri)
      throws Exception {
    showTitle("requestClientAssociate2");

    RegisterRequest registerRequest =
        new RegisterRequest(
            ApplicationType.WEB, "oxAuth test app", StringUtils.spaceSeparatedToList(redirectUris));
    registerRequest.setContacts(Arrays.asList("*****@*****.**", "*****@*****.**"));
    registerRequest.setScopes(
        Arrays.asList(
            "openid", "address", "profile", "email", "phone", "clientinfo", "invalid_scope"));
    registerRequest.setLogoUri("http://www.gluu.org/wp-content/themes/gluursn/images/logo.png");
    registerRequest.setTokenEndpointAuthMethod(AuthenticationMethod.CLIENT_SECRET_JWT);
    registerRequest.setPolicyUri("http://www.gluu.org/policy");
    registerRequest.setJwksUri("http://www.gluu.org/jwks");
    registerRequest.setSectorIdentifierUri(sectorIdentifierUri);
    registerRequest.setSubjectType(SubjectType.PAIRWISE);
    registerRequest.setRequestUris(Arrays.asList("http://www.gluu.org/request"));
    registerRequest.setFrontChannelLogoutUris(Lists.newArrayList(logoutUri));
    registerRequest.setFrontChannelLogoutSessionRequired(true);
    registerRequest.setIdTokenSignedResponseAlg(SignatureAlgorithm.RS512);
    registerRequest.setIdTokenEncryptedResponseAlg(KeyEncryptionAlgorithm.RSA1_5);
    registerRequest.setIdTokenEncryptedResponseEnc(BlockEncryptionAlgorithm.A128CBC_PLUS_HS256);
    registerRequest.setUserInfoSignedResponseAlg(SignatureAlgorithm.RS384);
    registerRequest.setUserInfoEncryptedResponseAlg(KeyEncryptionAlgorithm.A128KW);
    registerRequest.setUserInfoEncryptedResponseEnc(BlockEncryptionAlgorithm.A128GCM);
    registerRequest.setRequestObjectSigningAlg(SignatureAlgorithm.RS256);
    registerRequest.setRequestObjectEncryptionAlg(KeyEncryptionAlgorithm.A256KW);
    registerRequest.setRequestObjectEncryptionEnc(BlockEncryptionAlgorithm.A256CBC_PLUS_HS512);
    registerRequest.setTokenEndpointAuthMethod(AuthenticationMethod.CLIENT_SECRET_JWT);
    registerRequest.setTokenEndpointAuthSigningAlg(SignatureAlgorithm.ES256);

    RegisterClient registerClient = new RegisterClient(registrationEndpoint);
    registerClient.setRequest(registerRequest);
    registerClient.setExecutor(clientExecutor(true));
    RegisterResponse response = registerClient.exec();

    showClient(registerClient);
    assertEquals(response.getStatus(), 200, "Unexpected response code: " + response.getEntity());
    assertNotNull(response.getClientId());
    assertNotNull(response.getClientSecret());
    assertNotNull(response.getRegistrationAccessToken());
    assertNotNull(response.getClientSecretExpiresAt());
    assertNotNull(response.getClaims().get(SCOPES.toString()));
    assertNotNull(response.getClaims().get(FRONT_CHANNEL_LOGOUT_SESSION_REQUIRED.toString()));
    assertTrue(
        Boolean.parseBoolean(
            response.getClaims().get(FRONT_CHANNEL_LOGOUT_SESSION_REQUIRED.toString())));
    assertNotNull(response.getClaims().get(FRONT_CHANNEL_LOGOUT_URI.toString()));
    assertTrue(
        new JSONArray(response.getClaims().get(FRONT_CHANNEL_LOGOUT_URI.toString()))
            .getString(0)
            .equals(logoutUri));
    assertNotNull(response.getClaims().get(ID_TOKEN_SIGNED_RESPONSE_ALG.toString()));
    assertEquals(
        SignatureAlgorithm.RS512,
        SignatureAlgorithm.fromString(
            response.getClaims().get(ID_TOKEN_SIGNED_RESPONSE_ALG.toString())));
    assertNotNull(response.getClaims().get(ID_TOKEN_ENCRYPTED_RESPONSE_ALG.toString()));
    assertEquals(
        KeyEncryptionAlgorithm.RSA1_5,
        KeyEncryptionAlgorithm.fromName(
            response.getClaims().get(ID_TOKEN_ENCRYPTED_RESPONSE_ALG.toString())));
    assertNotNull(response.getClaims().get(ID_TOKEN_ENCRYPTED_RESPONSE_ENC.toString()));
    assertEquals(
        BlockEncryptionAlgorithm.A128CBC_PLUS_HS256,
        BlockEncryptionAlgorithm.fromName(
            response.getClaims().get(ID_TOKEN_ENCRYPTED_RESPONSE_ENC.toString())));
    assertNotNull(response.getClaims().get(USERINFO_SIGNED_RESPONSE_ALG.toString()));
    assertEquals(
        SignatureAlgorithm.RS384,
        SignatureAlgorithm.fromString(
            response.getClaims().get(USERINFO_SIGNED_RESPONSE_ALG.toString())));
    assertNotNull(response.getClaims().get(USERINFO_ENCRYPTED_RESPONSE_ALG.toString()));
    assertEquals(
        KeyEncryptionAlgorithm.A128KW,
        KeyEncryptionAlgorithm.fromName(
            response.getClaims().get(USERINFO_ENCRYPTED_RESPONSE_ALG.toString())));
    assertNotNull(response.getClaims().get(USERINFO_ENCRYPTED_RESPONSE_ENC.toString()));
    assertEquals(
        BlockEncryptionAlgorithm.A128GCM,
        BlockEncryptionAlgorithm.fromName(
            response.getClaims().get(USERINFO_ENCRYPTED_RESPONSE_ENC.toString())));
    assertNotNull(response.getClaims().get(REQUEST_OBJECT_SIGNING_ALG.toString()));
    assertEquals(
        SignatureAlgorithm.RS256,
        SignatureAlgorithm.fromString(
            response.getClaims().get(REQUEST_OBJECT_SIGNING_ALG.toString())));
    assertNotNull(response.getClaims().get(REQUEST_OBJECT_ENCRYPTION_ALG.toString()));
    assertEquals(
        KeyEncryptionAlgorithm.A256KW,
        KeyEncryptionAlgorithm.fromName(
            response.getClaims().get(REQUEST_OBJECT_ENCRYPTION_ALG.toString())));
    assertNotNull(response.getClaims().get(REQUEST_OBJECT_ENCRYPTION_ENC.toString()));
    assertEquals(
        BlockEncryptionAlgorithm.A256CBC_PLUS_HS512,
        BlockEncryptionAlgorithm.fromName(
            response.getClaims().get(REQUEST_OBJECT_ENCRYPTION_ENC.toString())));
    assertNotNull(response.getClaims().get(TOKEN_ENDPOINT_AUTH_METHOD.toString()));
    assertEquals(
        AuthenticationMethod.CLIENT_SECRET_JWT,
        AuthenticationMethod.fromString(
            response.getClaims().get(TOKEN_ENDPOINT_AUTH_METHOD.toString())));
    assertNotNull(response.getClaims().get(TOKEN_ENDPOINT_AUTH_SIGNING_ALG.toString()));
    assertEquals(
        SignatureAlgorithm.ES256,
        SignatureAlgorithm.fromString(
            response.getClaims().get(TOKEN_ENDPOINT_AUTH_SIGNING_ALG.toString())));
    JSONArray scopesJsonArray = new JSONArray(response.getClaims().get(SCOPES.toString()));
    List<String> scopes = new ArrayList<String>();
    for (int i = 0; i < scopesJsonArray.length(); i++) {
      scopes.add(scopesJsonArray.get(i).toString());
    }
    assertTrue(scopes.contains("openid"));
    assertTrue(scopes.contains("address"));
    assertTrue(scopes.contains("email"));
    assertTrue(scopes.contains("profile"));
    assertTrue(scopes.contains("phone"));
    assertTrue(scopes.contains("clientinfo"));

    clientId1 = response.getClientId();
    registrationAccessToken1 = response.getRegistrationAccessToken();
    registrationClientUri1 = response.getRegistrationClientUri();
  }
Exemplo n.º 16
0
 @Test
 public void testGetDomainsAsJSON() throws JSONException {
   JSONArray ja = r.path("domains").accept("application/json").get(JSONArray.class);
   assertEquals("No domain in " + ja, MBeanServerSetup.TESTDOMAIN, ja.get(0));
 }