@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);
}
@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);
}
}
@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);
}
@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);
}
}
@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);
}
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;
}