public static ClientProtocol.Message makeGetRequestMessage( ProtobufSerializationService serializationService, Object requestKey, String requestRegion) throws Exception { return ProtobufRequestUtilities.createGetRequest(requestRegion, serializationService.encode(requestKey)); }
public static ClientProtocol.Message makePutRequestMessage( ProtobufSerializationService serializationService, String requestKey, String requestValue, String requestRegion) throws EncodingException { BasicTypes.Entry entry = ProtobufUtilities.createEntry(serializationService.encode(requestKey), serializationService.encode(requestValue)); return ProtobufRequestUtilities.createPutRequest(requestRegion, entry); }
private RegionAPI.GetAllRequest generateTestRequest(boolean addKeys, boolean useInvalid) throws EncodingException { HashSet<BasicTypes.EncodedValue> testKeys = new HashSet<>(); if (addKeys) { testKeys.add(serializationService.encode(TEST_KEY1)); testKeys.add(serializationService.encode(TEST_KEY2)); testKeys.add(serializationService.encode(TEST_KEY3)); if (useInvalid) { testKeys.add(serializationService.encode(TEST_INVALID_KEY)); } } return ProtobufRequestUtilities.createGetAllRequest(TEST_REGION, testKeys); }
@Test public void testErrorReturnedWhenNoServers() throws Exception { when(serverLocatorAdviseeMock.processRequest(any(Object.class))).thenReturn(null); LocatorAPI.GetServerRequest getServerRequest = ProtobufRequestUtilities.createGetServerRequest(); Result operationHandlerResult = getOperationHandlerResult(getServerRequest); assertTrue(operationHandlerResult instanceof Failure); Failure failure = (Failure) operationHandlerResult; ClientProtocol.ErrorResponse errorResponse = failure.getErrorMessage(); assertEquals(NO_AVAILABLE_SERVER, errorResponse.getError().getErrorCode()); }
@Test public void processReturnsFailureForInvalidRegion() throws Exception { RegionAPI.ClearRequest removeRequest = ProtobufRequestUtilities.createClearRequest(MISSING_REGION).getClearRequest(); expectedException.expect(RegionDestroyedException.class); Result result = operationHandler.process(serializationService, removeRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); } }
private ClientProtocol.Message generateTestRequest(boolean missingRegion, boolean missingKey) throws EncodingException { String region = missingRegion ? MISSING_REGION : TEST_REGION; String key = missingKey ? MISSING_KEY : TEST_KEY; BasicTypes.EncodedValue testKey = serializationService.encode(key); return ProtobufRequestUtilities.createRemoveRequest(region, testKey); } }
@Test public void processReturnsNoCacheRegions() throws Exception { InternalCache emptyCache = mock(InternalCacheForClientAccess.class); doReturn(emptyCache).when(emptyCache).getCacheForProcessingClientRequests(); when(emptyCache.rootRegions()) .thenReturn(Collections.unmodifiableSet(new HashSet<Region<String, String>>())); Result result = operationHandler.process(serializationService, ProtobufRequestUtilities.createGetRegionNamesRequest(), getNoAuthCacheExecutionContext(emptyCache)); Assert.assertTrue(result instanceof Success); RegionAPI.GetRegionNamesResponse getRegionsResponse = (RegionAPI.GetRegionNamesResponse) result.getMessage(); Assert.assertEquals(0, getRegionsResponse.getRegionsCount()); } }
@Test public void processReturnsErrorUnableToDecodeRequest() throws Exception { Exception exception = new DecodingException("error finding codec for type"); ProtobufSerializationService serializationServiceStub = mock(ProtobufSerializationService.class); when(serializationServiceStub.decode(any())).thenReturn(TEST_KEY1, TEST_VALUE1) .thenThrow(exception); when(serializationServiceStub.encode(any())) .thenReturn(BasicTypes.EncodedValue.newBuilder().setStringResult("some string").build()); BasicTypes.EncodedValue encodedObject1 = BasicTypes.EncodedValue.newBuilder().setStringResult(TEST_KEY1).build(); BasicTypes.EncodedValue encodedObject2 = BasicTypes.EncodedValue.newBuilder().setStringResult(TEST_KEY2).build(); Set<BasicTypes.Entry> entries = new HashSet<>(); entries.add(ProtobufUtilities.createEntry(encodedObject1, encodedObject1)); entries.add(ProtobufUtilities.createEntry(encodedObject2, encodedObject2)); RegionAPI.PutAllRequest putAllRequest = ProtobufRequestUtilities.createPutAllRequest(TEST_REGION, entries).getPutAllRequest(); expectedException.expect(DecodingException.class); Result response = operationHandler.process(serializationServiceStub, putAllRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); }
@Test public void testServerReturnedFromHandler() throws Exception { when(serverLocatorAdviseeMock.processRequest(any(Object.class))) .thenReturn(new ClientConnectionResponse(new ServerLocation(HOSTNAME, PORT))); LocatorAPI.GetServerRequest getServerRequest = ProtobufRequestUtilities.createGetServerRequest(); Result operationHandlerResult = getOperationHandlerResult(getServerRequest); assertTrue(operationHandlerResult instanceof Success); validateGetServerResponse((GetServerResponse) operationHandlerResult.getMessage()); }
@Test public void processReturnsSuccessForValidRegion() throws Exception { RegionAPI.ClearRequest removeRequest = ProtobufRequestUtilities.createClearRequest(TEST_REGION).getClearRequest(); Result result = operationHandler.process(serializationService, removeRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); assertTrue(result instanceof Success); }
@Test(expected = DecodingException.class) public void processThrowsExceptionWhenUnableToDecodeRequest() throws Exception { Exception exception = new DecodingException("error finding codec for type"); ProtobufSerializationService serializationServiceStub = mock(ProtobufSerializationService.class); when(serializationServiceStub.decode(any())).thenThrow(exception); BasicTypes.EncodedValue encodedKey = BasicTypes.EncodedValue.newBuilder() .setJsonObjectResult("{\"someKey\":\"someValue\"}").build(); RegionAPI.RemoveRequest removeRequest = ProtobufRequestUtilities.createRemoveRequest(TEST_REGION, encodedKey).getRemoveRequest();; operationHandler.process(serializationServiceStub, removeRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); }
@Test public void processReturnsCacheRegions() throws Exception { Result result = operationHandler.process(serializationService, ProtobufRequestUtilities.createGetRegionNamesRequest(), getNoAuthCacheExecutionContext(cacheStub)); Assert.assertTrue(result instanceof Success); RegionAPI.GetRegionNamesResponse getRegionsResponse = (RegionAPI.GetRegionNamesResponse) result.getMessage(); Assert.assertEquals(3, getRegionsResponse.getRegionsCount()); // There's no guarantee for what order we receive the regions in from the response String name1 = getRegionsResponse.getRegions(0); String name2 = getRegionsResponse.getRegions(1); String name3 = getRegionsResponse.getRegions(2); Assert.assertTrue("The same region was returned multiple times", !name1.equals(name2) && !name1.equals(name3) && !name2.equals(name3)); ArrayList arrayList = new ArrayList(); arrayList.add(TEST_REGION1); arrayList.add(TEST_REGION2); arrayList.add(TEST_REGION3); assertTrue(arrayList.contains(name1)); assertTrue(arrayList.contains(name2)); assertTrue(arrayList.contains(name3)); }
private RegionAPI.PutAllRequest generateTestRequest(boolean addInvalidKey, boolean addValidKeys) throws EncodingException { Set<BasicTypes.Entry> entries = new HashSet<>(); if (addInvalidKey) { entries.add(ProtobufUtilities.createEntry(serializationService.encode(TEST_INVALID_KEY), serializationService.encode(TEST_INVALID_VALUE))); } if (addValidKeys) { entries.add(ProtobufUtilities.createEntry(serializationService.encode(TEST_KEY1), serializationService.encode(TEST_VALUE1))); entries.add(ProtobufUtilities.createEntry(serializationService.encode(TEST_KEY2), serializationService.encode(TEST_VALUE2))); entries.add(ProtobufUtilities.createEntry(serializationService.encode(TEST_KEY3), serializationService.encode(TEST_VALUE3))); } return ProtobufRequestUtilities.createPutAllRequest(TEST_REGION, entries).getPutAllRequest(); } }
private RegionAPI.GetRequest generateTestRequest(boolean missingRegion, boolean missingKey, boolean nulledKey) throws EncodingException { String region = missingRegion ? MISSING_REGION : TEST_REGION; String key = missingKey ? MISSING_KEY : (nulledKey ? NULLED_KEY : TEST_KEY); BasicTypes.EncodedValue testKey = serializationService.encode(key); return ProtobufRequestUtilities.createGetRequest(region, testKey).getGetRequest(); } }
private RegionAPI.PutRequest generateTestRequest() throws EncodingException { BasicTypes.EncodedValue testKey = serializationService.encode(TEST_KEY); BasicTypes.EncodedValue testValue = serializationService.encode(TEST_VALUE); BasicTypes.Entry testEntry = ProtobufUtilities.createEntry(testKey, testValue); return ProtobufRequestUtilities.createPutRequest(TEST_REGION, testEntry).getPutRequest(); } }
@Test public void testServerReturnedForExistentGroup() throws Exception { when( serverLocatorAdviseeMock.processRequest(new ClientConnectionRequest(any(), EXISTENT_GROUP))) .thenReturn(new ClientConnectionResponse(new ServerLocation(HOSTNAME, PORT))); LocatorAPI.GetServerRequest getServerRequest = ProtobufRequestUtilities.createGetServerRequest(EXISTENT_GROUP); Result operationHandlerResult = getOperationHandlerResult(getServerRequest); assertTrue(operationHandlerResult instanceof Success); validateGetServerResponse((GetServerResponse) operationHandlerResult.getMessage()); }
@Test public void processReturnsErrorUnableToDecodeRequest() throws Exception { Exception exception = new DecodingException("error finding codec for type"); ProtobufSerializationService serializationServiceStub = mock(ProtobufSerializationService.class); when(serializationServiceStub.decodeList(any())).thenThrow(exception); BasicTypes.EncodedValue encodedKey1 = BasicTypes.EncodedValue.newBuilder().setStringResult(TEST_KEY1).build(); BasicTypes.EncodedValue encodedKey2 = BasicTypes.EncodedValue.newBuilder().setStringResult(TEST_KEY2).build(); Set<BasicTypes.EncodedValue> keys = new HashSet<>(); keys.add(encodedKey1); keys.add(encodedKey2); RegionAPI.GetAllRequest getRequest = ProtobufRequestUtilities.createGetAllRequest(TEST_REGION, keys); expectedException.expect(DecodingException.class); operationHandler.process(serializationServiceStub, getRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); }
@Test(expected = DecodingException.class) public void processThrowsExceptionWhenUnableToDecodeRequest() throws Exception { Exception exception = new DecodingException("error finding codec for type"); ProtobufSerializationService serializationServiceStub = mock(ProtobufSerializationService.class); when(serializationServiceStub.decode(any())).thenThrow(exception); BasicTypes.EncodedValue encodedKey = BasicTypes.EncodedValue.newBuilder() .setJsonObjectResult("{\"someKey\":\"someValue\"}").build(); RegionAPI.GetRequest getRequest = ProtobufRequestUtilities.createGetRequest(TEST_REGION, encodedKey).getGetRequest(); operationHandler.process(serializationServiceStub, getRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); }
@Test(expected = DecodingException.class) public void processThrowsExceptionWhenUnableToDecode() throws Exception { String exceptionText = "unsupported type!"; Exception exception = new DecodingException(exceptionText); ProtobufSerializationService serializationServiceStub = mock(ProtobufSerializationService.class); when(serializationServiceStub.decode(any())).thenThrow(exception); BasicTypes.EncodedValue encodedKey = BasicTypes.EncodedValue.newBuilder() .setJsonObjectResult("{\"someKey\":\"someValue\"}").build(); PutRequestOperationHandler operationHandler = new PutRequestOperationHandler(); BasicTypes.EncodedValue testValue = serializationService.encode(TEST_VALUE); BasicTypes.Entry testEntry = ProtobufUtilities.createEntry(encodedKey, testValue); RegionAPI.PutRequest putRequest = ProtobufRequestUtilities.createPutRequest(TEST_REGION, testEntry).getPutRequest(); operationHandler.process(serializationServiceStub, putRequest, TestExecutionContext.getNoAuthCacheExecutionContext(cacheStub)); }
@Test public void testErrorReturnedForNonexistentGroup() throws Exception { when(serverLocatorAdviseeMock .processRequest(new ClientConnectionRequest(any(), NONEXISTENT_GROUP))) .thenReturn(new ClientConnectionResponse(null)); LocatorAPI.GetServerRequest getServerRequest = ProtobufRequestUtilities.createGetServerRequest(NONEXISTENT_GROUP); Result operationHandlerResult = getOperationHandlerResult(getServerRequest); assertTrue(operationHandlerResult instanceof Failure); Failure failure = (Failure) operationHandlerResult; ClientProtocol.ErrorResponse errorResponse = failure.getErrorMessage(); assertEquals(NO_AVAILABLE_SERVER, errorResponse.getError().getErrorCode()); assertTrue(errorResponse.getError().getMessage().contains(NONEXISTENT_GROUP)); }