/** Tests the delete request. */
@SuppressWarnings("javadoc")
public class DeleteRequestTestCase extends RequestsTestCase {
private static final DeleteRequest NEW_DELETE_REQUEST =
Requests.newDeleteRequest(DN.valueOf("uid=Deleterequest1"));
private static final DeleteRequest NEW_DELETE_REQUEST2 =
Requests.newDeleteRequest("cn=Deleterequesttestcase");
private static final DeleteRequest NEW_DELETE_REQUEST3 =
Requests.newDeleteRequest("uid=user.999,ou=people,o=test");
@DataProvider(name = "deleteRequests")
private Object[][] getDeleteRequests() throws Exception {
return createModifiableInstance();
}
@Override
protected DeleteRequest[] newInstance() {
return new DeleteRequest[] {NEW_DELETE_REQUEST, NEW_DELETE_REQUEST2, NEW_DELETE_REQUEST3};
}
@Override
protected Request copyOf(Request original) {
return Requests.copyOfDeleteRequest((DeleteRequest) original);
}
@Override
protected Request unmodifiableOf(Request original) {
return Requests.unmodifiableDeleteRequest((DeleteRequest) original);
}
@Test(dataProvider = "deleteRequests")
public void testModifiableRequest(final DeleteRequest original) {
final String newValue = "uid=newName";
final DeleteRequest copy = (DeleteRequest) copyOf(original);
copy.setName(newValue);
assertThat(copy.getName().toString()).isEqualTo(newValue);
assertThat(original.getName().toString()).isNotEqualTo(newValue);
}
@Test(dataProvider = "deleteRequests")
public void testUnmodifiableRequest(final DeleteRequest original) {
final DeleteRequest unmodifiable = (DeleteRequest) unmodifiableOf(original);
assertThat(unmodifiable.getName().toString()).isEqualTo(original.getName().toString());
}
@Test(dataProvider = "deleteRequests", expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetName(final DeleteRequest original) {
final DeleteRequest unmodifiable = (DeleteRequest) unmodifiableOf(original);
unmodifiable.setName("uid=scarter,ou=people,dc=example,dc=com");
}
@Test(dataProvider = "deleteRequests", expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetName2(final DeleteRequest original) {
final DeleteRequest unmodifiable = (DeleteRequest) unmodifiableOf(original);
unmodifiable.setName(DN.valueOf("uid=scarter,ou=people,dc=example,dc=com"));
}
}
@Test(dataProvider = "annotatedRequestHandlerData")
public void testActionCollectionItemAnnotatedRequestHandler(
Class<?> requestHandler,
boolean collection,
boolean create,
boolean read,
boolean update,
boolean delete,
boolean patch,
boolean resourceAction,
boolean collectionAction,
boolean query)
throws Exception {
// Given
Object provider = requestHandler.newInstance();
Connection connection = Resources.newInternalConnection(createHandler(collection, provider));
ActionRequest req1 = Requests.newActionRequest("/test/fred", "instanceAction1");
ActionRequest req2 = Requests.newActionRequest("/test/fred", "instanceAction2");
// When
Promise<JsonValue, ResourceException> promise1 =
connection.actionAsync(new RootContext(), req1);
Promise<JsonValue, ResourceException> promise2 =
connection.actionAsync(new RootContext(), req2);
// Then
if (collectionAction && collection) {
AssertJJsonValueAssert.assertThat(promise1)
.succeeded()
.stringAt("result")
.isEqualTo("instanceAction1-fred");
AssertJJsonValueAssert.assertThat(promise2)
.succeeded()
.stringAt("result")
.isEqualTo("instanceAction2-fred");
} else if (collection) {
AssertJJsonValueAssert.assertThat(promise1)
.failedWithException()
.isInstanceOf(NotSupportedException.class);
AssertJJsonValueAssert.assertThat(promise2)
.failedWithException()
.isInstanceOf(NotSupportedException.class);
} else {
AssertJJsonValueAssert.assertThat(promise1)
.failedWithException()
.isInstanceOf(NotFoundException.class);
AssertJJsonValueAssert.assertThat(promise2)
.failedWithException()
.isInstanceOf(NotFoundException.class);
}
}
@Test(dataProvider = "annotatedRequestHandlerData")
public void testUpdateAnnotatedRequestHandler(
Class<?> requestHandler,
boolean collection,
boolean create,
boolean read,
boolean update,
boolean delete,
boolean patch,
boolean resourceAction,
boolean collectionAction,
boolean query)
throws Exception {
// Given
Object provider = requestHandler.newInstance();
Connection connection = Resources.newInternalConnection(createHandler(collection, provider));
UpdateRequest req = Requests.newUpdateRequest("/test", json(object(field("dummy", "test"))));
// When
Promise<Resource, ResourceException> promise = connection.updateAsync(new RootContext(), req);
// Then
if (update && !collection) {
assertThat(promise).succeeded().withId().isEqualTo("update");
} else if (!collection) {
assertThat(promise).failedWithException().isInstanceOf(NotSupportedException.class);
} else {
assertThat(promise).failedWithException().isInstanceOf(BadRequestException.class);
}
}
@Test(dataProvider = "annotatedRequestHandlerData")
public void testPatchCollectionItemAnnotatedRequestHandler(
Class<?> requestHandler,
boolean collection,
boolean create,
boolean read,
boolean update,
boolean delete,
boolean patch,
boolean resourceAction,
boolean collectionAction,
boolean query)
throws Exception {
// Given
Object provider = requestHandler.newInstance();
Connection connection = Resources.newInternalConnection(createHandler(collection, provider));
PatchRequest req = Requests.newPatchRequest("/test/fred");
// When
Promise<Resource, ResourceException> promise = connection.patchAsync(new RootContext(), req);
// Then
if (patch && collection) {
assertThat(promise).succeeded().withId().isEqualTo("patch-fred");
} else if (collection) {
assertThat(promise).failedWithException().isInstanceOf(NotSupportedException.class);
} else {
assertThat(promise).failedWithException().isInstanceOf(NotFoundException.class);
}
}
@Test
// request FD
public void testParseVersion() throws StiebelHeatPumpException {
// verify the version from heat pump
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "Version";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0xb5,
(byte) 0xfd,
(byte) 0x01,
(byte) 0xb6,
(byte) 0x10,
(byte) 0x03
};
Map<String, String> data = parser.parseRecords(response, result.get(0));
data.get("Version");
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Assert.assertEquals("4.38", data.get("Version"));
}
@Test
public void testCopyHeadersClusterAdminRequest() {
Map<String, String> transportHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> restHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> copiedHeaders = randomHeadersFrom(restHeaders);
Set<String> usefulRestHeaders = new HashSet<>(copiedHeaders.keySet());
usefulRestHeaders.addAll(randomMap(randomIntBetween(0, 10), "useful-").keySet());
Map<String, String> restContext = randomContext(randomIntBetween(0, 10));
Map<String, String> transportContext =
Maps.difference(randomContext(randomIntBetween(0, 10)), restContext).entriesOnlyOnLeft();
HashMap<String, String> expectedHeaders = new HashMap<>();
expectedHeaders.putAll(transportHeaders);
expectedHeaders.putAll(copiedHeaders);
Map<String, String> expectedContext = new HashMap<>();
expectedContext.putAll(transportContext);
expectedContext.putAll(restContext);
Client client =
client(
new NoOpClient(), new FakeRestRequest(restHeaders, expectedContext), usefulRestHeaders);
ClusterHealthRequest clusterHealthRequest = Requests.clusterHealthRequest();
putHeaders(clusterHealthRequest, transportHeaders);
putContext(clusterHealthRequest, transportContext);
assertHeaders(clusterHealthRequest, transportHeaders);
client.admin().cluster().health(clusterHealthRequest);
assertHeaders(clusterHealthRequest, expectedHeaders);
assertContext(clusterHealthRequest, expectedContext);
ClusterStateRequest clusterStateRequest = Requests.clusterStateRequest();
putHeaders(clusterStateRequest, transportHeaders);
putContext(clusterStateRequest, transportContext);
assertHeaders(clusterStateRequest, transportHeaders);
client.admin().cluster().state(clusterStateRequest);
assertHeaders(clusterStateRequest, expectedHeaders);
assertContext(clusterStateRequest, expectedContext);
ClusterStatsRequest clusterStatsRequest = Requests.clusterStatsRequest();
putHeaders(clusterStatsRequest, transportHeaders);
putContext(clusterStatsRequest, transportContext);
assertHeaders(clusterStatsRequest, transportHeaders);
client.admin().cluster().clusterStats(clusterStatsRequest);
assertHeaders(clusterStatsRequest, expectedHeaders);
assertContext(clusterStatsRequest, expectedContext);
}
@Test
public void testCopyHeadersIndicesAdminRequest() {
Map<String, String> transportHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> restHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> copiedHeaders = randomHeadersFrom(restHeaders);
Set<String> usefulRestHeaders = new HashSet<>(copiedHeaders.keySet());
usefulRestHeaders.addAll(randomMap(randomIntBetween(0, 10), "useful-").keySet());
Map<String, String> restContext = randomContext(randomIntBetween(0, 10));
Map<String, String> transportContext =
Maps.difference(randomContext(randomIntBetween(0, 10)), restContext).entriesOnlyOnLeft();
HashMap<String, String> expectedHeaders = new HashMap<>();
expectedHeaders.putAll(transportHeaders);
expectedHeaders.putAll(copiedHeaders);
Map<String, String> expectedContext = new HashMap<>();
expectedContext.putAll(transportContext);
expectedContext.putAll(restContext);
Client client =
client(new NoOpClient(), new FakeRestRequest(restHeaders, restContext), usefulRestHeaders);
CreateIndexRequest createIndexRequest = Requests.createIndexRequest("test");
putHeaders(createIndexRequest, transportHeaders);
putContext(createIndexRequest, transportContext);
assertHeaders(createIndexRequest, transportHeaders);
client.admin().indices().create(createIndexRequest);
assertHeaders(createIndexRequest, expectedHeaders);
assertContext(createIndexRequest, expectedContext);
CloseIndexRequest closeIndexRequest = Requests.closeIndexRequest("test");
putHeaders(closeIndexRequest, transportHeaders);
putContext(closeIndexRequest, transportContext);
assertHeaders(closeIndexRequest, transportHeaders);
client.admin().indices().close(closeIndexRequest);
assertHeaders(closeIndexRequest, expectedHeaders);
assertContext(closeIndexRequest, expectedContext);
FlushRequest flushRequest = Requests.flushRequest();
putHeaders(flushRequest, transportHeaders);
putContext(flushRequest, transportContext);
assertHeaders(flushRequest, transportHeaders);
client.admin().indices().flush(flushRequest);
assertHeaders(flushRequest, expectedHeaders);
assertContext(flushRequest, expectedContext);
}
@Test
public void testCopyHeadersRequest() {
Map<String, String> transportHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> restHeaders = randomHeaders(randomIntBetween(0, 10));
Map<String, String> copiedHeaders = randomHeadersFrom(restHeaders);
Set<String> usefulRestHeaders = new HashSet<>(copiedHeaders.keySet());
usefulRestHeaders.addAll(randomMap(randomIntBetween(0, 10), "useful-").keySet());
Map<String, String> restContext = randomContext(randomIntBetween(0, 10));
Map<String, String> transportContext =
Maps.difference(randomContext(randomIntBetween(0, 10)), restContext).entriesOnlyOnLeft();
Map<String, String> expectedHeaders = new HashMap<>();
expectedHeaders.putAll(transportHeaders);
expectedHeaders.putAll(copiedHeaders);
Map<String, String> expectedContext = new HashMap<>();
expectedContext.putAll(transportContext);
expectedContext.putAll(restContext);
Client client =
client(new NoOpClient(), new FakeRestRequest(restHeaders, restContext), usefulRestHeaders);
SearchRequest searchRequest = Requests.searchRequest();
putHeaders(searchRequest, transportHeaders);
putContext(searchRequest, transportContext);
assertHeaders(searchRequest, transportHeaders);
client.search(searchRequest);
assertHeaders(searchRequest, expectedHeaders);
assertContext(searchRequest, expectedContext);
GetRequest getRequest = Requests.getRequest("index");
putHeaders(getRequest, transportHeaders);
putContext(getRequest, transportContext);
assertHeaders(getRequest, transportHeaders);
client.get(getRequest);
assertHeaders(getRequest, expectedHeaders);
assertContext(getRequest, expectedContext);
IndexRequest indexRequest = Requests.indexRequest();
putHeaders(indexRequest, transportHeaders);
putContext(indexRequest, transportContext);
assertHeaders(indexRequest, transportHeaders);
client.index(indexRequest);
assertHeaders(indexRequest, expectedHeaders);
assertContext(indexRequest, expectedContext);
}
/*
* Initiate {@code CLIENT LIST} on all connections and return the {@link Requests}.
*
* @return the {@link Requests}.
*/
public Requests requestClients() {
Requests requests = new Requests();
for (Map.Entry<RedisURI, StatefulRedisConnection<String, String>> entry :
connections.entrySet()) {
CommandArgs<String, String> args =
new CommandArgs<>(ClusterTopologyRefresh.CODEC).add(CommandKeyword.LIST);
Command<String, String, String> command =
new Command<>(CommandType.CLIENT, new StatusOutput<>(ClusterTopologyRefresh.CODEC), args);
TimedAsyncCommand<String, String, String> timedCommand = new TimedAsyncCommand<>(command);
entry.getValue().dispatch(timedCommand);
requests.addRequest(entry.getKey(), timedCommand);
}
return requests;
}
@Override
protected Void doInBackground(Void... voids) {
final VKRequest vkRequest = Requests.vkFriendsRequest(Requests.LOCALE_RUS);
vkRequest.executeWithListener(
new VKRequest.VKRequestListener() {
@Override
public void onComplete(VKResponse response) {
super.onComplete(response);
vkTask = new ParseVkResponseTask(vkFriends, listener, response);
vkTask.setShowResults(false);
vkTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
});
while (vkTask == null) {}
try {
vkTask.get();
Request fbRequest = Requests.fbFriendsRequest();
Response response = fbRequest.executeAndWait();
fbTask = new ParseFbResponseTask(fbFriends, listener, response);
fbTask.setShowResults(false);
Handler mainHandler = new Handler(Looper.getMainLooper());
mainHandler.post(
new Runnable() {
@Override
public void run() {
fbTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
});
fbTask.get();
} catch (Exception e) {
e.printStackTrace();
return null;
}
fillSyncContactsList();
storeSyncContacts();
return null;
}
@SuppressWarnings("unchecked")
@Test(dataProvider = "testCollectionResourceProviderData")
public void testCollectionResourceProvider(String resourcePath, String expectedId)
throws Exception {
CollectionResourceProvider collection = mock(CollectionResourceProvider.class);
RequestHandler handler = Resources.newCollection(collection);
Connection connection = Resources.newInternalConnection(handler);
ReadRequest read = Requests.newReadRequest(resourcePath);
connection.readAsync(new RootContext(), read);
ArgumentCaptor<ReadRequest> captor = ArgumentCaptor.forClass(ReadRequest.class);
verify(collection).readInstance(any(ServerContext.class), eq(expectedId), captor.capture());
Assertions.assertThat(captor.getValue().getResourcePath()).isEqualTo("");
}
@Test
// request OC
public void testParseSettingsDomesticWater() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsDomesticHotWater";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x8e,
(byte) 0x07,
(byte) 0x14,
(byte) 0x5a,
(byte) 0xff,
(byte) 0x9c,
(byte) 0x1e,
(byte) 0x07,
(byte) 0x00,
(byte) 0x64,
(byte) 0x03,
(byte) 0x02,
(byte) 0xee,
(byte) 0x01,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("2.0", data.get("P32StartupHysteresisDHWTemperature"));
Assert.assertEquals("90", data.get("P33TimeDelayElectricalReheating"));
Assert.assertEquals("-10.0", data.get("P34OutsideTemperatureLimitForImmElectricalReheating"));
Assert.assertEquals("30", data.get("P35PasteurisationInterval"));
Assert.assertEquals("7", data.get("P36MaxDurationDHWLoading"));
Assert.assertEquals("10.0", data.get("PasteurisationHeatupTemperature"));
Assert.assertEquals("3", data.get("NoOfEnabledElectricalReheatStagesDHWLoading"));
Assert.assertEquals("75.0", data.get("MaxFlowTemperatureDHWMode"));
Assert.assertEquals("1", data.get("CompressorShutdownDHWLoading"));
}
@Test(dataProvider = "annotatedRequestHandlerData")
public void testActionAnnotatedRequestHandler(
Class<?> requestHandler,
boolean collection,
boolean create,
boolean read,
boolean update,
boolean delete,
boolean patch,
boolean resourceAction,
boolean collectionAction,
boolean query)
throws Exception {
// Given
Object provider = requestHandler.newInstance();
Connection connection = Resources.newInternalConnection(createHandler(collection, provider));
String actionId1 = collection ? "collectionAction1" : "instanceAction1";
ActionRequest req1 = Requests.newActionRequest("/test", actionId1);
String actionId2 = collection ? "collectionAction2" : "instanceAction2";
ActionRequest req2 = Requests.newActionRequest("/test", actionId2);
// When
Promise<JsonValue, ResourceException> promise1 =
connection.actionAsync(new RootContext(), req1);
Promise<JsonValue, ResourceException> promise2 =
connection.actionAsync(new RootContext(), req2);
// Then
if ((collection && collectionAction) || (!collection && resourceAction)) {
assertThatJsonValue(promise1).succeeded().stringAt("result").isEqualTo(actionId1);
assertThatJsonValue(promise2).succeeded().stringAt("result").isEqualTo(actionId2);
} else {
assertThatJsonValue(promise1).failedWithException().isInstanceOf(NotSupportedException.class);
assertThatJsonValue(promise2).failedWithException().isInstanceOf(NotSupportedException.class);
}
}
@Test
@Ignore
// request FC
public void testParseTime2() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "Time";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x6a,
(byte) 0xfc,
(byte) 0x00,
(byte) 0x06,
(byte) 0x15,
(byte) 0x27,
(byte) 0x0a,
(byte) 0x0f,
(byte) 0x00,
(byte) 0x02,
(byte) 0x10,
(byte) 0x10,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("2", data.get("WeekDay"));
Assert.assertEquals("21", data.get("Hours"));
Assert.assertEquals("33", data.get("Minutes"));
Assert.assertEquals("36", data.get("Seconds"));
Assert.assertEquals("14", data.get("Year"));
Assert.assertEquals("2", data.get("Month"));
Assert.assertEquals("8", data.get("Day"));
}
@Test
// request O3
public void testParseSettingsEvaporator1() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsEvaporator1";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x0e,
(byte) 0x03,
(byte) 0x00,
(byte) 0x96,
(byte) 0x00,
(byte) 0x0a,
(byte) 0x00,
(byte) 0x96,
(byte) 0x00,
(byte) 0x64,
(byte) 0x10,
(byte) 0x10,
(byte) 0x60,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("15.0", data.get("UpperLimitEvaporatorTemperatureForDefrostEnd"));
Assert.assertEquals("10", data.get("MaxEvaporatorDefrostTime"));
Assert.assertEquals("15.0", data.get("LimitTemperatureCondenserElectricalReheating"));
Assert.assertEquals("10.0", data.get("LimitTemperatureCondenserDefrostTermination"));
Assert.assertEquals("16", data.get("P47CompressorRestartDelay"));
Assert.assertEquals("96", data.get("P48ExhaustFanSpeed"));
}
@Test
// request O9
public void testParseOperationCounters() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "OperationCounters";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0xea,
(byte) 0x09,
(byte) 0x00,
(byte) 0x1a,
(byte) 0x00,
(byte) 0x19,
(byte) 0x0c,
(byte) 0x77,
(byte) 0x02,
(byte) 0x28,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("26", data.get("CompressorA"));
Assert.assertEquals("25", data.get("CompressorB"));
Assert.assertEquals("3191", data.get("HeatingMode"));
Assert.assertEquals("552", data.get("DHWMode"));
Assert.assertEquals("0", data.get("CoolingMode"));
}
@Test
// request 10
public void testParseSettingsDryHeatingProgram() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsDryHeatingProgram";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0xa8,
(byte) 0x10,
(byte) 0x10,
(byte) 0x00,
(byte) 0x00,
(byte) 0xfa,
(byte) 0x01,
(byte) 0x90,
(byte) 0x00,
(byte) 0x02,
(byte) 0x00,
(byte) 0x0a,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("0", data.get("P70Start"));
Assert.assertEquals("25.0", data.get("P71BaseTemperature"));
Assert.assertEquals("40.0", data.get("P72PeakTemperature"));
Assert.assertEquals("2", data.get("P73BaseTemperatureDuration"));
Assert.assertEquals("1.0", data.get("P74Increase"));
}
@Test
// request OC
public void testParseSettingsDomesticWaterProgram() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsDomesticHotWaterProgram";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x1d,
(byte) 0x0c,
(byte) 0x08,
(byte) 0x98,
(byte) 0x01,
(byte) 0xf4,
(byte) 0x7b,
(byte) 0x00,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("2200", data.get("BP1StartTime"));
Assert.assertEquals("500", data.get("BP1StopTime"));
Assert.assertEquals("1", data.get("BP1Monday"));
Assert.assertEquals("1", data.get("BP1Tuesday"));
Assert.assertEquals("0", data.get("BP1Wednesday"));
Assert.assertEquals("1", data.get("BP1Thusday"));
Assert.assertEquals("1", data.get("BP1Friday"));
Assert.assertEquals("1", data.get("BP1Saturday"));
Assert.assertEquals("1", data.get("BP1Sunday"));
Assert.assertEquals("0", data.get("BP1Enabled"));
}
@Test
// request OA
public void testParseSettingsCirculationPump() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsCirculationPump";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0xeb,
(byte) 0x0a,
(byte) 0x01,
(byte) 0x01,
(byte) 0x20,
(byte) 0x00,
(byte) 0xba,
(byte) 0x00,
(byte) 0xc8,
(byte) 0x00,
(byte) 0x3c,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("1", data.get("P54minStartupCycles"));
Assert.assertEquals("288", data.get("P55maxStartupCycles"));
Assert.assertEquals("18.6", data.get("P56OutsideTemperatureMinHeatingCycles"));
Assert.assertEquals("20.0", data.get("P57OutsideTemperatureMaxHeatingCycles"));
Assert.assertEquals("60", data.get("P58SuppressTemperatureCaptureDuringPumpStart"));
}
@Test(dataProvider = "dataWithoutVersionHeader")
@SuppressWarnings("unchecked")
public void shouldRouteActionRequestsUsingDefaultVersionBehaviour(
String resource,
DefaultVersionBehaviour versionBehaviour,
boolean expectException,
RequestHandler provider) {
// Given
AcceptAPIVersionContext apiVersionContext =
new AcceptAPIVersionContext(
new RootContext(),
"PROTOCOL_NAME",
AcceptAPIVersion.newBuilder().withDefaultProtocolVersion("1.0").build());
ServerContext context = new ServerContext(apiVersionContext);
ActionRequest request =
Requests.newActionRequest(resource, "ACTION_ID").setContent(json(object()));
ResultHandler<JsonValue> handler = mock(ResultHandler.class);
setDefaultVersionBehaviour(router, versionBehaviour);
// When
router.handleAction(context, request, handler);
// Then
if (expectException) {
ArgumentCaptor<ResourceException> exceptionCaptor =
ArgumentCaptor.forClass(ResourceException.class);
verify(handler).handleError(exceptionCaptor.capture());
assertThat(exceptionCaptor.getValue()).isInstanceOf(BadRequestException.class);
verifyZeroInteractions(
usersHandlerOne,
usersHandlerTwo,
usersHandlerThree,
groupsHandlerOne,
groupsHandlerTwo,
groupsHandlerThree);
} else {
verify(provider)
.handleAction(
Matchers.<ServerContext>anyObject(),
Matchers.<ActionRequest>anyObject(),
eq(handler));
}
}
@Test(dataProvider = "dataWithVersionHeader")
@SuppressWarnings("unchecked")
public void shouldRouteDeleteVersionRequests(
String resource, String requestedVersion, boolean expectException, RequestHandler provider) {
// Given
AcceptAPIVersionContext apiVersionContext =
new AcceptAPIVersionContext(
new RootContext(),
"PROTOCOL_NAME",
AcceptAPIVersion.newBuilder()
.withDefaultProtocolVersion("1.0")
.withDefaultResourceVersion(requestedVersion)
.build());
ServerContext context = new ServerContext(apiVersionContext);
DeleteRequest request = Requests.newDeleteRequest(resource);
ResultHandler<Resource> handler = mock(ResultHandler.class);
// When
router.handleDelete(context, request, handler);
// Then
if (expectException) {
ArgumentCaptor<ResourceException> exceptionCaptor =
ArgumentCaptor.forClass(ResourceException.class);
verify(handler).handleError(exceptionCaptor.capture());
assertThat(exceptionCaptor.getValue()).isInstanceOf(NotFoundException.class);
verifyZeroInteractions(
usersHandlerOne,
usersHandlerTwo,
usersHandlerThree,
groupsHandlerOne,
groupsHandlerTwo,
groupsHandlerThree);
} else {
verify(provider)
.handleDelete(
Matchers.<ServerContext>anyObject(),
Matchers.<DeleteRequest>anyObject(),
eq(handler));
}
}
@Test
// request 0E
public void testParseSettingsRestartAndMixerTime() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsRestartAndMixerTime";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x09,
(byte) 0x0e,
(byte) 0x00,
(byte) 0x78,
(byte) 0x00,
(byte) 0x64,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x1e,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("120", data.get("P59RestartBeforSetbackEnd"));
Assert.assertEquals("10.0", data.get("MixerProportionalRange"));
Assert.assertEquals("0.0", data.get("DerivativeMixerTime"));
Assert.assertEquals("30", data.get("MixerTimeInterval"));
}
@Test
// request O4
public void testParseSettingsEvaporator2() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsEvaporator2";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x00,
(byte) 0x04,
(byte) 0x3c,
(byte) 0x00,
(byte) 0x64,
(byte) 0x00,
(byte) 0x5a,
(byte) 0x01,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("60", data.get("MaxDefrostDurationAAExchanger"));
Assert.assertEquals("10.0", data.get("DefrostStartThreshold"));
Assert.assertEquals("90", data.get("VolumeFlowFilterReplacement"));
Assert.assertEquals("1", data.get("P85DefrostModeAAHE"));
}
@Test
// request OD
public void testParseSettingsAbsenceProgram() throws StiebelHeatPumpException {
List<Request> result =
Requests.searchIn(
configuration,
new Matcher<Request>() {
@Override
public boolean matches(Request r) {
return r.getName() == "SettingsAbsenceProgram";
}
});
byte[] response =
new byte[] {
(byte) 0x01,
(byte) 0x00,
(byte) 0x10,
(byte) 0x10,
(byte) 0x0f,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x10,
(byte) 0x03
};
response = parser.fixDuplicatedBytes(response);
Assert.assertEquals(response[3], result.get(0).getRequestByte());
Assert.assertEquals(response[2], parser.calculateChecksum(response));
Map<String, String> data = parser.parseRecords(response, result.get(0));
Assert.assertEquals("0.0", data.get("AP0DurationUntilAbsenceStart"));
Assert.assertEquals("0.0", data.get("AP0AbsenceDuration"));
Assert.assertEquals("0", data.get("AP0EnableAbsenceProgram"));
}
@Test(dataProvider = "annotatedRequestHandlerData")
public void testQueryCollectionAnnotatedRequestHandler(
Class<?> requestHandler,
boolean collection,
boolean create,
boolean read,
boolean update,
boolean delete,
boolean patch,
boolean resourceAction,
boolean collectionAction,
boolean query)
throws Exception {
// Given
Object provider = requestHandler.newInstance();
Connection connection = Resources.newInternalConnection(createHandler(collection, provider));
QueryRequest req = Requests.newQueryRequest("/test");
// When
Promise<QueryResult, ResourceException> promise =
connection.queryAsync(new RootContext(), req, mock(QueryResourceHandler.class));
// Then
if (query && collection) {
AssertJPromiseAssert.assertThat(promise).succeeded();
QueryResult result = promise.get();
Assertions.assertThat(result.getPagedResultsCookie()).isEqualTo("query");
} else if (collection) {
AssertJPromiseAssert.assertThat(promise)
.failedWithException()
.isInstanceOf(NotSupportedException.class);
} else {
AssertJPromiseAssert.assertThat(promise)
.failedWithException()
.isInstanceOf(BadRequestException.class);
}
}
@Override
protected Request unmodifiableOf(Request original) {
return Requests.unmodifiablePlainSASLBindRequest((PlainSASLBindRequest) original);
}
@Override
protected Request copyOf(Request original) {
return Requests.copyOfPlainSASLBindRequest((PlainSASLBindRequest) original);
}
/** Tests Plain SASL Bind requests. */
@SuppressWarnings("javadoc")
public class PlainSASLBindRequestTestCase extends RequestsTestCase {
private static final PlainSASLBindRequest NEW_PLAIN_SASL_BIND_REQUEST =
Requests.newPlainSASLBindRequest("id1", EMPTY_BYTES);
private static final PlainSASLBindRequest NEW_PLAIN_SASL_BIND_REQUEST2 =
Requests.newPlainSASLBindRequest("id2", getBytes("password"));
@DataProvider(name = "plainSASLBindRequests")
private Object[][] getPlainSASLBindRequests() throws Exception {
return createModifiableInstance();
}
@Override
protected PlainSASLBindRequest[] newInstance() {
return new PlainSASLBindRequest[] {NEW_PLAIN_SASL_BIND_REQUEST, NEW_PLAIN_SASL_BIND_REQUEST2};
}
@Override
protected Request copyOf(Request original) {
return Requests.copyOfPlainSASLBindRequest((PlainSASLBindRequest) original);
}
@Override
protected Request unmodifiableOf(Request original) {
return Requests.unmodifiablePlainSASLBindRequest((PlainSASLBindRequest) original);
}
@Test(dataProvider = "plainSASLBindRequests")
public void testModifiableRequest(final PlainSASLBindRequest original) {
final String authID = "u:user.0";
final String azID = "dn:user.0,dc=com";
final String password = "******";
final PlainSASLBindRequest copy = (PlainSASLBindRequest) copyOf(original);
copy.setAuthenticationID(authID);
copy.setAuthorizationID(azID);
copy.setPassword(password.toCharArray());
assertThat(copy.getAuthenticationID()).isEqualTo(authID);
assertThat(copy.getAuthorizationID()).isEqualTo(azID);
assertThat(original.getAuthenticationID()).isNotEqualTo(copy.getAuthenticationID());
assertThat(original.getAuthorizationID()).isNotEqualTo(copy.getAuthorizationID());
}
@Test(dataProvider = "plainSASLBindRequests")
public void testUnmodifiableRequest(final PlainSASLBindRequest original) {
final PlainSASLBindRequest unmodifiable = (PlainSASLBindRequest) unmodifiableOf(original);
assertThat(unmodifiable.getName()).isEqualTo(original.getName());
assertThat(unmodifiable.getAuthorizationID()).isEqualTo(original.getAuthorizationID());
assertThat(unmodifiable.getAuthenticationID()).isEqualTo(original.getAuthenticationID());
assertThat(unmodifiable.getSASLMechanism()).isEqualTo(original.getSASLMechanism());
}
@Test(
dataProvider = "plainSASLBindRequests",
expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetAuthenticationID(final PlainSASLBindRequest original) {
final PlainSASLBindRequest unmodifiable = (PlainSASLBindRequest) unmodifiableOf(original);
unmodifiable.setAuthenticationID("dn: uid=scarter,ou=people,dc=example,dc=com");
}
@Test(
dataProvider = "plainSASLBindRequests",
expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetAuthorizationID(final PlainSASLBindRequest original) {
final PlainSASLBindRequest unmodifiable = (PlainSASLBindRequest) unmodifiableOf(original);
unmodifiable.setAuthorizationID("dn: uid=scarter,ou=people,dc=example,dc=com");
}
@Test(
dataProvider = "plainSASLBindRequests",
expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetPassword(final PlainSASLBindRequest original) {
final PlainSASLBindRequest unmodifiable = (PlainSASLBindRequest) unmodifiableOf(original);
unmodifiable.setPassword("password".toCharArray());
}
@Test(
dataProvider = "plainSASLBindRequests",
expectedExceptions = UnsupportedOperationException.class)
public void testUnmodifiableSetPassword2(final PlainSASLBindRequest original) {
final PlainSASLBindRequest unmodifiable = (PlainSASLBindRequest) unmodifiableOf(original);
unmodifiable.setPassword("password".getBytes());
}
}
@Override
protected Request unmodifiableOf(Request original) {
return Requests.unmodifiableDeleteRequest((DeleteRequest) original);
}
@Override
protected Request copyOf(Request original) {
return Requests.copyOfDeleteRequest((DeleteRequest) original);
}
