示例#1
0
  @Test(
      dataProvider =
          com.linkedin.restli.internal.common.TestConstants.RESTLI_PROTOCOL_1_2_PREFIX
              + "requestOptionsDataProvider")
  public void testAssociationBatchGetEntityCompoundKeyResponse(RestliRequestOptions requestOptions)
      throws RemoteInvocationException {
    CompoundKey key1 = buildCompoundKey(1, 1);
    CompoundKey key2 = buildCompoundKey(2, 1);
    Set<CompoundKey> allRequestedKeys = new HashSet<CompoundKey>(Arrays.asList(key1, key2));

    Request<BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>>> request =
        new GroupMembershipsRequestBuilders(requestOptions)
            .batchGet()
            .ids(key1, key2)
            .fields(GroupMembership.fields().contactEmail())
            .build();
    BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>> groupMemberships =
        getClient().sendRequest(request).getResponse().getEntity();

    Assert.assertTrue(allRequestedKeys.containsAll(groupMemberships.getResults().keySet()));
    Assert.assertTrue(allRequestedKeys.containsAll(groupMemberships.getErrors().keySet()));
    Set<CompoundKey> allResponseKeys =
        new HashSet<CompoundKey>(groupMemberships.getResults().keySet());
    allResponseKeys.addAll(groupMemberships.getErrors().keySet());
    Assert.assertEquals(allResponseKeys, allRequestedKeys);
  }
示例#2
0
  @Test(
      dataProvider =
          com.linkedin.restli.internal.common.TestConstants.RESTLI_PROTOCOL_1_2_PREFIX
              + "requestMembershipsBuilderDataProvider")
  public void testAssociationCreateGetDelete(
      ProtocolVersion version, RootBuilderWrapper<CompoundKey, GroupMembership> membershipBuilders)
      throws RemoteInvocationException {
    // Setup - create group memberships
    CompoundKey key1 = buildCompoundKey(1, 1);
    GroupMembership groupMembership1 =
        buildGroupMembership(null, "*****@*****.**", "Alfred", "Hitchcock");

    Response<EmptyRecord> response =
        getClient()
            .sendRequest(membershipBuilders.update().id(key1).input(groupMembership1).build())
            .getResponse();
    Assert.assertEquals(response.getStatus(), 204);

    // Get membership
    Request<GroupMembership> getRequest =
        membershipBuilders.get().id(key1).fields(GroupMembership.fields().contactEmail()).build();
    GroupMembership groupMembership = getClient().sendRequest(getRequest).getResponse().getEntity();
    Assert.assertEquals(groupMembership.getContactEmail(), "*****@*****.**");

    // Delete the newly created group membership
    Response<EmptyRecord> deleteResponse =
        getClient().sendRequest(membershipBuilders.delete().id(key1).build()).getResponse();
    Assert.assertEquals(deleteResponse.getStatus(), 204);

    // Make sure it is gone
    try {
      getClient().sendRequest(getRequest).getResponse();
    } catch (RestLiResponseException e) {
      Assert.assertEquals(e.getStatus(), 404);
    }
  }
示例#3
0
  @Test(
      dataProvider =
          com.linkedin.restli.internal.common.TestConstants.RESTLI_PROTOCOL_1_2_PREFIX
              + "requestComplexBuilderDataProvider")
  public void testComplexKeyBatchCreateGetUpdateDelete(
      ProtocolVersion version,
      RootBuilderWrapper<
              ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>,
              ComplexKeyGroupMembership>
          builders)
      throws RemoteInvocationException {
    ComplexResourceKey<GroupMembershipKey, GroupMembershipParam> complexKey1 =
        buildComplexKey(1, 1, 10, "String1");
    ComplexKeyGroupMembership groupMembership1 =
        buildComplexKeyGroupMembership(
            complexKey1.getKey(), "*****@*****.**", "alfred", "hitchcock");
    ComplexResourceKey<GroupMembershipKey, GroupMembershipParam> complexKey2 =
        buildComplexKey(2, 1, 20, "String2");
    ComplexKeyGroupMembership groupMembership2 =
        buildComplexKeyGroupMembership(
            complexKey2.getKey(), "*****@*****.**", "bruce", "willis");
    ComplexResourceKey<GroupMembershipKey, GroupMembershipParam> complexKey3 =
        buildComplexKey(3, 1, 30, "String3");
    ComplexKeyGroupMembership groupMembership3 =
        buildComplexKeyGroupMembership(
            complexKey3.getKey(), "*****@*****.**", "carole", "bouquet");

    Request<CollectionResponse<CreateStatus>> createRequest =
        builders
            .batchCreate()
            .input(groupMembership1)
            .input(groupMembership2)
            .input(groupMembership3)
            .build();
    Response<CollectionResponse<CreateStatus>> createResponse =
        getClient().sendRequest(createRequest).getResponse();
    Assert.assertEquals(createResponse.getStatus(), 200);

    final RestliRequestOptions requestOptions = builders.getRequestOptions();
    @SuppressWarnings("unchecked")
    Request<
            BatchKVResponse<
                ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>,
                EntityResponse<ComplexKeyGroupMembership>>>
        request =
            new GroupMembershipsComplexRequestBuilders(requestOptions)
                .batchGet()
                .ids(complexKey1, complexKey2, complexKey3)
                .fields(GroupMembership.fields().contactEmail())
                .build();
    BatchKVResponse<
            ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>,
            EntityResponse<ComplexKeyGroupMembership>>
        groupMemberships = getClient().sendRequest(request).getResponse().getEntity();
    Map<
            ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>,
            EntityResponse<ComplexKeyGroupMembership>>
        results = groupMemberships.getResults();
    ComplexKeyGroupMembership groupMembership1_ = results.get(complexKey1).getEntity();
    ComplexKeyGroupMembership groupMembership2_ = results.get(complexKey2).getEntity();
    ComplexKeyGroupMembership groupMembership3_ = results.get(complexKey3).getEntity();
    Assert.assertNotNull(groupMembership1_);
    Assert.assertEquals(groupMembership1_.getContactEmail(), "*****@*****.**");
    Assert.assertNotNull(groupMembership2_);
    Assert.assertEquals(groupMembership2_.getContactEmail(), "*****@*****.**");
    Assert.assertNotNull(groupMembership3_);
    Assert.assertEquals(groupMembership3_.getContactEmail(), "*****@*****.**");

    // Update and verify
    groupMembership1.setContactEmail("*****@*****.**");
    groupMembership2.setContactEmail("*****@*****.**");
    groupMembership3.setContactEmail("*****@*****.**");
    Request<
            BatchKVResponse<
                ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>, UpdateStatus>>
        updateRequest =
            builders
                .batchUpdate()
                .input(complexKey1, groupMembership1)
                .input(complexKey2, groupMembership2)
                .input(complexKey3, groupMembership3)
                .build();
    int status = getClient().sendRequest(updateRequest).getResponse().getStatus();
    Assert.assertEquals(status, 200);
  }
示例#4
0
  @Test(
      dataProvider =
          com.linkedin.restli.internal.common.TestConstants.RESTLI_PROTOCOL_1_2_PREFIX
              + "requestComplexBuilderDataProvider")
  public void testComplexKeyCreateGetUpdateDelete(
      ProtocolVersion version,
      RootBuilderWrapper<
              ComplexResourceKey<GroupMembershipKey, GroupMembershipParam>,
              ComplexKeyGroupMembership>
          builders)
      throws RemoteInvocationException {
    // Create a new complex key resource
    ComplexResourceKey<GroupMembershipKey, GroupMembershipParam> complexKey =
        buildComplexKey(1, 1, 10, "String1");
    ComplexKeyGroupMembership groupMembership =
        buildComplexKeyGroupMembership(
            complexKey.getKey(), "*****@*****.**", "alfred", "hitchcock");

    Request<EmptyRecord> createRequest = builders.create().input(groupMembership).build();
    Response<EmptyRecord> createResponse = getClient().sendRequest(createRequest).getResponse();
    Assert.assertEquals(createResponse.getStatus(), 201);

    GroupMembershipParam param = new GroupMembershipParam();
    param.setIntParameter(1);
    param.setStringParameter("1");

    GroupMembershipQueryParam groupMembershipQueryParam1 = new GroupMembershipQueryParam();
    groupMembershipQueryParam1.setIntParameter(1);
    groupMembershipQueryParam1.setStringParameter("1");
    GroupMembershipQueryParam groupMembershipQueryParam2 = new GroupMembershipQueryParam();
    groupMembershipQueryParam2.setIntParameter(2);
    groupMembershipQueryParam2.setStringParameter("2");
    GroupMembershipQueryParamArray queryParamArray =
        new GroupMembershipQueryParamArray(
            Arrays.asList(groupMembershipQueryParam1, groupMembershipQueryParam2));
    // Get the resource back and check state
    Request<ComplexKeyGroupMembership> request =
        builders
            .get()
            .id(complexKey)
            .fields(GroupMembership.fields().contactEmail())
            .setQueryParam("testParam", param)
            .setQueryParam("testParamArray", queryParamArray)
            .build();
    ComplexKeyGroupMembership groupMembership1 =
        getClient().sendRequest(request).getResponse().getEntity();
    Assert.assertNotNull(groupMembership1);
    Assert.assertEquals(groupMembership1.getContactEmail(), "*****@*****.**");

    // Test the same with optional complex parameters
    request = builders.get().id(complexKey).fields(GroupMembership.fields().contactEmail()).build();
    groupMembership1 = getClient().sendRequest(request).getResponse().getEntity();
    Assert.assertNotNull(groupMembership1);
    Assert.assertEquals(groupMembership1.getContactEmail(), "*****@*****.**");

    // Update contact email and verify
    groupMembership.setContactEmail("*****@*****.**");
    Request<EmptyRecord> updateRequest =
        builders.update().id(complexKey).input(groupMembership).build();
    Response<EmptyRecord> updateResponse = getClient().sendRequest(updateRequest).getResponse();
    Assert.assertEquals(updateResponse.getStatus(), 204);

    groupMembership1 = getClient().sendRequest(request).getResponse().getEntity();
    Assert.assertEquals(groupMembership1.getContactEmail(), "*****@*****.**");

    // Delete and verify
    Request<EmptyRecord> deleteRequest = builders.delete().id(complexKey).build();
    Response<EmptyRecord> deleteResponse = getClient().sendRequest(deleteRequest).getResponse();
    Assert.assertEquals(deleteResponse.getStatus(), 204);
    try {
      getClient().sendRequest(request).getResponse().getEntity();
    } catch (RestLiResponseException e) {
      Assert.assertEquals(e.getStatus(), 404);
    }
  }
示例#5
0
  @Test(
      dataProvider =
          com.linkedin.restli.internal.common.TestConstants.RESTLI_PROTOCOL_1_2_PREFIX
              + "requestMembershipsBuilderDataProvider")
  public void testAssociationBatchCreateGetUpdatePatchDelete(
      ProtocolVersion version, RootBuilderWrapper<CompoundKey, GroupMembership> membershipBuilders)
      throws RemoteInvocationException {
    // Setup - batch create two group memberships
    CompoundKey key1 = buildCompoundKey(1, 1);
    CompoundKey key2 = buildCompoundKey(2, 1);
    GroupMembership groupMembership1 =
        buildGroupMembership(null, "*****@*****.**", "Alfred", "Hitchcock");
    GroupMembership groupMembership2 =
        buildGroupMembership(null, "*****@*****.**", "Bruce", "Willis");
    Map<CompoundKey, UpdateStatus> results =
        getClient()
            .sendRequest(
                membershipBuilders
                    .batchUpdate()
                    .input(key1, groupMembership1)
                    .input(key2, groupMembership2)
                    .build())
            .getResponse()
            .getEntity()
            .getResults();
    Assert.assertEquals(results.get(key1).getStatus().intValue(), 204);
    Assert.assertEquals(results.get(key2).getStatus().intValue(), 204);

    // BatchGet memberships
    final RestliRequestOptions requestOptions = membershipBuilders.getRequestOptions();
    Request<BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>>> request =
        new GroupMembershipsRequestBuilders(requestOptions)
            .batchGet()
            .ids(key1, key2)
            .fields(GroupMembership.fields().contactEmail())
            .build();
    Map<CompoundKey, EntityResponse<GroupMembership>> groupMemberships =
        getClient().sendRequest(request).getResponse().getEntity().getResults();
    Assert.assertTrue(groupMemberships.containsKey(key1));
    Assert.assertEquals(
        groupMemberships.get(key1).getEntity().getContactEmail(), "*****@*****.**");
    Assert.assertTrue(groupMemberships.containsKey(key2));
    Assert.assertEquals(
        groupMemberships.get(key2).getEntity().getContactEmail(), "*****@*****.**");

    // Batch partial update
    GroupMembership patchedGroupMembership1 =
        buildGroupMembership(null, "*****@*****.**", "ALFRED", "Hitchcock");
    GroupMembership patchedGroupMembership2 =
        buildGroupMembership(null, "*****@*****.**", "BRUCE", "Willis");

    Map<CompoundKey, PatchRequest<GroupMembership>> patchInputs =
        new HashMap<CompoundKey, PatchRequest<GroupMembership>>();
    patchInputs.put(key1, PatchGenerator.diff(groupMembership1, patchedGroupMembership1));
    patchInputs.put(key2, PatchGenerator.diff(groupMembership2, patchedGroupMembership2));

    Map<CompoundKey, UpdateStatus> patchResults =
        getClient()
            .sendRequest(membershipBuilders.batchPartialUpdate().patchInputs(patchInputs).build())
            .getResponse()
            .getEntity()
            .getResults();
    Assert.assertEquals(patchResults.get(key1).getStatus().intValue(), 204);
    Assert.assertEquals(patchResults.get(key2).getStatus().intValue(), 204);

    // Batch get to make sure our patch applied
    Request<BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>>> batchGetRequest =
        new GroupMembershipsRequestBuilders(requestOptions)
            .batchGet()
            .ids(key1, key2)
            .fields(GroupMembership.fields().contactEmail(), GroupMembership.fields().firstName())
            .build();
    BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>> entity =
        getClient().sendRequest(batchGetRequest).getResponse().getEntity();
    Assert.assertEquals(entity.getErrors().size(), 0);
    Assert.assertEquals(entity.getResults().size(), 2);
    Assert.assertEquals(
        entity.getResults().get(key1).getEntity().getContactEmail(), "*****@*****.**");
    Assert.assertEquals(entity.getResults().get(key1).getEntity().getFirstName(), "ALFRED");
    Assert.assertEquals(
        entity.getResults().get(key2).getEntity().getContactEmail(), "*****@*****.**");
    Assert.assertEquals(entity.getResults().get(key2).getEntity().getFirstName(), "BRUCE");

    // GetAll memberships
    Request<CollectionResponse<GroupMembership>> getAllRequest =
        membershipBuilders
            .getAll()
            .paginate(1, 2)
            .fields(GroupMembership.fields().contactEmail())
            .build();
    List<GroupMembership> elements =
        getClient().sendRequest(getAllRequest).getResponse().getEntity().getElements();
    Assert.assertEquals(elements.size(), 1);

    // Delete the newly created group memberships
    Map<CompoundKey, UpdateStatus> deleteResult =
        getClient()
            .sendRequest(membershipBuilders.batchDelete().ids(key1, key2).build())
            .getResponse()
            .getEntity()
            .getResults();
    Assert.assertEquals(deleteResult.get(key1).getStatus().intValue(), 204);
    Assert.assertEquals(deleteResult.get(key2).getStatus().intValue(), 204);

    // Make sure they are gone
    BatchKVResponse<CompoundKey, EntityResponse<GroupMembership>> getResponse =
        getClient().sendRequest(request).getResponse().getEntity();
    Assert.assertEquals(getResponse.getResults().size(), getResponse.getErrors().size());
    Assert.assertTrue(getResponse.getErrors().containsKey(key1));
    Assert.assertTrue(getResponse.getErrors().containsKey(key2));
    Assert.assertEquals(getResponse.getErrors().get(key1).getStatus().intValue(), 404);
    Assert.assertEquals(getResponse.getErrors().get(key2).getStatus().intValue(), 404);
  }
示例#6
0
  private static GroupMembership buildGroupMembership(
      Integer id, String contactEmail, String firstName, String lastName) {
    GroupMembership groupMembership = new GroupMembership();
    if (id != null) {
      groupMembership.setMemberID(id);
    }
    groupMembership.setContactEmail(contactEmail);
    groupMembership.setFirstName(firstName);
    groupMembership.setLastName(lastName);
    // These fields must be set when creating a stand-alone group membership,
    // lest the membership be considered incomplete.
    groupMembership.setAllowMessagesFromMembers(true);
    groupMembership.setEmailAnnouncementsFromManagers(true);
    groupMembership.setEmailDigestFrequency(EmailDigestFrequency.WEEKLY);
    groupMembership.setEmailForEveryNewPost(true);
    groupMembership.setIsPublicized(true);
    groupMembership.setMembershipLevel(MembershipLevel.MEMBER);
    groupMembership.setWriteLevel(WriteLevel.DEFAULT);

    return groupMembership;
  }