/** * Test for {@link ModuleMonitoring#deleteMonitoringCheck(int)}. */ @TestTemplate void testDeleteMonitoringCheck(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(delete(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring/1234")).willReturn (aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testDeleteMonitoringCheck.json"))); Response<Boolean> response = api.monitoring().deleteMonitoringCheck(1234); List<Message> messages = response.getMessages(); Message message = messages.get(0); boolean result = response.getResult(); assertEquals("Der Monitoring-Check Test(M1234) wird geloescht", message.getMessageText()); assertEquals(MessageType.SUCCESS, message.getType()); assertTrue(result); }
/** * Test for {@link ModuleMonitoring#getStatus(int)}. */ @TestTemplate void testGetStatus(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring/1234/status")) .willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testGetStatus.json"))); Response<Map<String, MonitoringStatus>> response = api.monitoring().getStatus(1234); List<Message> messages = response.getMessages(); MonitoringStatus result = response.getResult().get("1234"); assertTrue(messages.isEmpty()); assertEquals(0, result.getCode()); assertEquals("OK - 123.45.67.89: rta 0.313ms, lost 0%", result.getResponse()); }
/** * Test for {@link ModuleMonitoring#getStatuses(String)}. */ @TestTemplate void testGetStatuses(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring/123.45.67.89/status")) .willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testGetStatuses.json"))); Response<Map<String, MonitoringStatus>> response = api.monitoring().getStatuses("123.45.67.89"); List<Message> messages = response.getMessages(); Map<String, MonitoringStatus> result = response.getResult(); MonitoringStatus monitoringStatus1 = result.get("1234"); MonitoringStatus monitoringStatus2 = result.get("5678"); assertTrue(messages.isEmpty()); assertEquals(0, monitoringStatus1.getCode()); assertEquals("OK - 123.45.67.89: rta 0.313ms, lost 0%", monitoringStatus1.getResponse()); assertEquals(0, monitoringStatus2.getCode()); assertEquals("HTTP OK: Status line output matched "200" " + "-3827 bytes in 0.003 second response " + "time", monitoringStatus2 .getResponse()); }
/** * Test for {@link ModuleBackups#createPeriodicalBackups(int, int, int)}. */ @TestTemplate void testCreatePeriodicalBackups(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/backups/12345")); StringValuePattern body = equalToJson("{\"dayid\": 0, \"timeid\": 1}", false, false); wireMock.stubFor(builder.withRequestBody(body) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testCreatePeriodicalBackups.json"))); Response<BackupConfig> response = api.backups().createPeriodicalBackups(12345, 0, 1); List<Message> messages = response.getMessages(); BackupConfig backup = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(0, backup.getDayid()); assertEquals(1, backup.getTimeid()); }
/** * Test for {@link ModuleBackups#updatePeriodicalBackups(int, int, int)}. */ @TestTemplate void testUpdatePeriodicalBackups(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = put(urlPathEqualTo("/00000000000000000000000000000000/v1.0/backups/12345")); StringValuePattern body = equalToJson("{\"dayid\": 0, \"timeid\": 1}", false, false); wireMock.stubFor(builder.withRequestBody(body) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testUpdatePeriodicalBackups.json"))); Response<BackupConfig> response = api.backups().updatePeriodicalBackups(12345, 0, 1); List<Message> messages = response.getMessages(); BackupConfig backup = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(0, backup.getDayid()); assertEquals(1, backup.getTimeid()); }
/** * Test for {@link ModuleBackups#deletePeriodicalBackups(int)}. */ @TestTemplate void testDeletePeriodicalBackups(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = delete(urlPathEqualTo("/00000000000000000000000000000000/v1.0/backups/12345")); wireMock.stubFor(builder.willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testDeletePeriodicalBackups.json"))); Response<Boolean> response = api.backups().deletePeriodicalBackups(12345); List<Message> messages = response.getMessages(); Boolean result = response.getResult(); assertTrue(messages.isEmpty()); assertTrue(result); }
/** * Test for {@link ModuleBackups#createManualBackup(int)}. */ @TestTemplate void testCreateManualBackup(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/backups/12345/manual")); StringValuePattern body = equalToJson("{}", false, false); wireMock.stubFor(builder.withRequestBody(body) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testCreateManualBackups.json"))); Response<Boolean> response = api.backups().createManualBackup(12345); List<Message> messages = response.getMessages(); Boolean result = response.getResult(); assertTrue(messages.isEmpty()); assertTrue(result); }
/** * Test for {@link ModuleBackups#deleteBackup(int, String, String)}. */ @TestTemplate void testDeleteBackup(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = delete(urlPathEqualTo ("/00000000000000000000000000000000/v1.0/backups/12345/daily/12345ACDEF")); wireMock.stubFor(builder.willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testDeleteBackup.json"))); Response<Boolean> response = api.backups().deleteBackup(12345, "daily", "12345ACDEF"); List<Message> messages = response.getMessages(); Boolean result = response.getResult(); assertTrue(messages.isEmpty()); assertTrue(result); }
/** * Test for {@link ModuleBackups#restoreBackup(int, String, String)}. */ @TestTemplate void testRestoreBackup(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = post(urlPathEqualTo ("/00000000000000000000000000000000/v1.0/backups/12345/daily/12345ACDEF")); StringValuePattern body = equalToJson("{}", false, false); wireMock.stubFor(builder.withRequestBody(body) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testRestoreBackup.json"))); Response<Boolean> response = api.backups().restoreBackup(12345, "daily", "12345ACDEF"); List<Message> messages = response.getMessages(); Boolean result = response.getResult(); assertTrue(messages.isEmpty()); assertTrue(result); }
/** * Test for {@link ModulePlans#getPlan(int)}. */ @TestTemplate void testGetPlan(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/plans/45")).willReturn(aResponse ().withHeaders(WireMockHelper .headers()).withStatus(200).withBodyFile("modules/plans/testGetPlan.json"))); Response<Plan> response = api.plans().getPlan(45); List<Message> messages = response.getMessages(); Plan result = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(2, result.getCpus()); assertEquals(204800, result.getDiskSizeInMB()); assertEquals(45, result.getId()); assertEquals("CloudLevel 2", result.getName()); assertEquals(19.99, result.getPriceCap(), 0.001); assertEquals(0.03, result.getPricePerHour(), 0.001); assertEquals(0.01, result.getPricePerHourFrozen(), 0.001); assertEquals(4096, result.getRamInMB()); }
/** * Test for {@link ModulePlans#getPlan(String)}. */ @TestTemplate void testGetPlan1(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/plans/CloudLevel%202")) .willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/plans/testGetPlan1.json"))); Response<Plan> response = api.plans().getPlan("CloudLevel 2"); List<Message> messages = response.getMessages(); Plan result = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(2, result.getCpus()); assertEquals(204800, result.getDiskSizeInMB()); assertEquals(45, result.getId()); assertEquals("CloudLevel 2", result.getName()); assertEquals(19.99, result.getPriceCap(), 0.001); assertEquals(0.03, result.getPricePerHour(), 0.001); assertEquals(0.01, result.getPricePerHourFrozen(), 0.001); assertEquals(4096, result.getRamInMB()); }
/** * Test for {@link ModuleContactGroups#deleteContactGroup(int)}. */ @TestTemplate void testDeleteContactGroup(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(delete(urlPathEqualTo("/00000000000000000000000000000000/v1.0/contactGroups/123")) .willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/contactGroups/testDeleteContactGroup.json"))); Response<Boolean> response = api.contactGroups().deleteContactGroup(123); List<Message> messages = response.getMessages(); Boolean result = response.getResult(); assertTrue(messages.isEmpty()); assertTrue(result); }
/** * Test for {@link ModuleJiffyBoxes#deleteJiffyBox(int)}. */ @TestTemplate void testDeleteJiffyBox(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(delete(urlPathEqualTo("/00000000000000000000000000000000/v1.0/jiffyBoxes/12345")).willReturn (aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/jiffyBoxes/testDeleteJiffyBox.json"))); Response<Boolean> response = api.jiffyBoxes().deleteJiffyBox(12345); List<Message> messages = response.getMessages(); assertTrue(messages.isEmpty()); assertTrue(response.getResult()); }
/** * Test for {@link ModuleJiffyBoxes#duplicateJiffyBox(int, String, int, ObjectNode)}. */ @TestTemplate void testDuplicateJiffyBoxWithMetadata1(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/jiffyBoxes/12345")) .withRequestBody(equalToJson("{\"name\": \"Test\", \"planid\": 10, \"metadata\":{\"createdBy\": " + "\"The" + " " + "JiffyBoxTeam\", \"usedBy\": [\"Me\", \"You\", \"Everyone\"], " + "\"freeForAll\":false}}")) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/jiffyBoxes/testDuplicateJiffyBoxWithMetadata1.json"))); ObjectNode metadata = Build.metadata().put("createdBy", "The JiffyBoxTeam"); metadata.putArray("usedBy").add("Me").add("You").add("Everyone"); metadata.put("freeForAll", false); Response<JiffyBox> response = api.jiffyBoxes().duplicateJiffyBox(12345, "Test", 10, metadata); testDuplicateJiffyBoxResponse(response); }
/** * Test for {@link ModuleJiffyBoxes#duplicateJiffyBox(int, String, String, ObjectNode)}. */ @TestTemplate void testDuplicateJiffyBoxWithMetadata2(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/jiffyBoxes/12345")) .withRequestBody(equalToJson("{\"name\": \"Test\", \"planid\": \"CloudLevel 1\", " + "\"metadata\":{\"createdBy\": " + "\"The JiffyBoxTeam\", \"usedBy\": [\"Me\", \"You\", " + "\"Everyone\"], " + "\"freeForAll\":false}}")) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/jiffyBoxes/testDuplicateJiffyBoxWithMetadata2.json"))); ObjectNode metadata = Build.metadata().put("createdBy", "The JiffyBoxTeam"); metadata.putArray("usedBy").add("Me").add("You").add("Everyone"); metadata.put("freeForAll", false); Response<JiffyBox> response = api.jiffyBoxes().duplicateJiffyBox(12345, "Test", "CloudLevel 1", metadata); testDuplicateJiffyBoxResponse(response); }
/** * Test for {@link ModuleDoc#getDocs()}. */ @TestTemplate void testGetDocs(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/doc")).willReturn(aResponse() .withHeaders(WireMockHelper .headers()).withStatus(200).withBodyFile("modules/doc/testGetDocs.json"))); Response<Map<String, String>> response = api.doc().getDocs(); List<Message> messages = response.getMessages(); assertTrue(messages.isEmpty()); Map<String, String> docs = response.getResult(); assertEquals("Modul zur Monitoring-Verwaltung", docs.get("Monitoring")); assertEquals("Modul zum Auflisten und Manipulieren von JiffyBoxen", docs.get("JiffyBoxes")); assertEquals("Dokumentationsmodul", docs.get("Doc")); assertEquals("Modul zum Auflisten von installierbaren Linux-Distributionen", docs.get("Distributions")); assertEquals("Modul zum Auflisten und ändern von IP-Adressen", docs.get("Ips")); assertEquals("Modul zum Auflisten von JiffyBox-Tarifen", docs.get("Plans")); assertEquals("Modul zum Auflisten und Beantragen von Backups", docs.get("Backups")); assertEquals("Modul zur Verwaltung von Kontaktgruppen", docs.get("ContactGroups")); }
/** * Test for {@link ModuleDistributions#getDistribution(String)}. */ @TestTemplate void testGetDistribution(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/distributions/centos_5_4_64bit")) .willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/distributions/testGetDistribution.json"))); Response<Distribution> response = api.distributions().getDistribution("centos_5_4_64bit"); List<Message> messages = response.getMessages(); Distribution distribution = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(1024, distribution.getMinDiskSizeMB()); assertEquals("xen-current-x86_64", distribution.getDefaultKernel()); assertEquals("CentOS 5.4 64-Bit", distribution.getName()); assertEquals("ro", distribution.getRootdiskMode()); }
private static String getSurefireOutputFolder(Method testMethod, Class<?> testInstance) { Annotation[] annotations = testMethod.getAnnotations(); StringBuilder stringBuilder = new StringBuilder( "./target/surefire-reports/"); boolean isTestTemplate = stream(annotations) .map(Annotation::annotationType) .anyMatch(a -> a == TestTemplate.class); log.trace("Is test template? {}", isTestTemplate); if (isTestTemplate) { stringBuilder.append(testMethod.getName()); stringBuilder.append("("); Class<?>[] parameterTypes = testMethod.getParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { if (i != 0) { stringBuilder.append(", "); } stringBuilder.append(parameterTypes[i].getSimpleName()); } stringBuilder.append(")/"); } else { stringBuilder.append(testInstance.getName()); } return stringBuilder.toString(); }
@TestTemplate void templateTest(WebDriver driver1, WebDriver driver2) { driver1.get("https://bonigarcia.github.io/selenium-jupiter/"); driver2.get("https://bonigarcia.github.io/selenium-jupiter/"); assertThat(driver1.getTitle(), containsString("A JUnit 5 extension for Selenium WebDriver")); assertThat(driver2.getTitle(), containsString("A JUnit 5 extension for Selenium WebDriver")); }
/** * Test for {@link ModuleMonitoring#getMonitoringChecks()}. */ @TestTemplate void testGetMonitoringChecks(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring")).willReturn(aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testGetMonitoringChecks.json"))); Response<Map<String, MonitoringCheck>> response = api.monitoring().getMonitoringChecks(); List<Message> messages = response.getMessages(); Map<String, MonitoringCheck> result = response.getResult(); MonitoringCheck monitoringCheck = result.get("911"); List<ContactGroup> contactGroups = monitoringCheck.getContactgroups(); ContactGroup contactGroup = contactGroups.get(0); assertTrue(messages.isEmpty()); assertEquals(300, monitoringCheck.getCheckInterval()); assertEquals(MonitoringCheckType.HTTP, monitoringCheck.getCheckType()); assertEquals("example.com", monitoringCheck.getDomainname()); assertEquals(1234, monitoringCheck.getId()); assertEquals("188.93.14.165", monitoringCheck.getIp()); assertEquals(4849, monitoringCheck.getJiffyBox()); assertEquals("test", monitoringCheck.getName()); assertEquals("", monitoringCheck.getPassword()); assertEquals("/index.php", monitoringCheck.getPath()); assertEquals(80, monitoringCheck.getPort()); assertEquals(3600, monitoringCheck.getReminderInterval()); assertEquals(3, monitoringCheck.getRetryTolerance()); assertEquals(MonitoringCheckStatus.STATUS_READY, monitoringCheck.getStatus()); assertEquals("", monitoringCheck.getUsername()); assertTrue(contactGroup.getContacts().isEmpty()); assertEquals(123, contactGroup.getId()); assertEquals("TestGruppe", contactGroup.getName()); assertNull(contactGroup.getStatus()); }
/** * Test for {@link ModuleMonitoring#getMonitoringCheck(int)}. */ @TestTemplate void testGetMonitoringCheck(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring/1234")).willReturn (aResponse() .withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testGetMonitoringCheck.json"))); Response<MonitoringCheck> response = api.monitoring().getMonitoringCheck(1234); List<Message> messages = response.getMessages(); MonitoringCheck result = response.getResult(); List<ContactGroup> contactGroups = result.getContactgroups(); ContactGroup contactGroup = contactGroups.get(0); assertTrue(messages.isEmpty()); assertEquals(300, result.getCheckInterval()); assertEquals(MonitoringCheckType.HTTP, result.getCheckType()); assertEquals("example.com", result.getDomainname()); assertEquals(1234, result.getId()); assertEquals("188.93.14.211", result.getIp()); assertEquals(4849, result.getJiffyBox()); assertEquals("test", result.getName()); assertEquals("", result.getPassword()); assertEquals("/index.php", result.getPath()); assertEquals(80, result.getPort()); assertEquals(3600, result.getReminderInterval()); assertEquals(3, result.getRetryTolerance()); assertEquals(MonitoringCheckStatus.STATUS_READY, result.getStatus()); assertEquals("", result.getUsername()); assertTrue(contactGroup.getContacts().isEmpty()); assertEquals(123, contactGroup.getId()); assertEquals("TestGruppe", contactGroup.getName()); assertNull(contactGroup.getStatus()); }
/** * Test for {@link ModuleMonitoring#createMonitoringCheck(MonitoringCheckBuilder)}. */ @TestTemplate void testCreateMonitoringCheck(WireMockServer wireMock, JiffyBoxApi api) { String body = "{\"name\": \"Test\", \"ip\": \"188.93.14.211\", \"checkType\":\"http\", \"port\": 80, " + "\"path\": \"/index.php\", \"domainname\": \"example.com\"}"; wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring")).withRequestBody (equalToJson(body, false, false)) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testCreateMonitoringCheck.json"))); MonitoringCheckBuilder data = Build.monitoringCheck("Test", "188.93.14.211", 80) .http("example.com", "/index.php"); Response<MonitoringCheck> response = api.monitoring().createMonitoringCheck(data); List<Message> messages = response.getMessages(); MonitoringCheck result = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(300, result.getCheckInterval()); assertEquals(MonitoringCheckType.HTTP, result.getCheckType()); assertTrue(result.getContactgroups().isEmpty()); assertEquals("example.com", result.getDomainname()); assertEquals(1234, result.getId()); assertEquals("188.93.14.211", result.getIp()); assertEquals(4849, result.getJiffyBox()); assertEquals("Test", result.getName()); assertNull(result.getPassword()); assertEquals("/index.php", result.getPath()); assertEquals(80, result.getPort()); assertEquals(3600, result.getReminderInterval()); assertEquals(3, result.getRetryTolerance()); assertEquals(MonitoringCheckStatus.STATUS_CREATING, result.getStatus()); assertNull(result.getUsername()); }
/** * Test for {@link ModuleMonitoring#duplicateMonitoringCheck(int, MonitoringCheckBuilder)}. */ @TestTemplate void testDuplicateMonitoringCheck(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/monitoring/1234")) .withRequestBody(equalToJson("{\"name\": \"Kopie von Test\", \"ip\": \"188.93.14.212\"}", false, false)) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/monitoring/testDuplicateMonitoringCheck.json"))); MonitoringCheckBuilder data = Build.monitoringCheck("Kopie von Test", "188.93.14.212", null).preserveType(); Response<MonitoringCheck> response = api.monitoring().duplicateMonitoringCheck(1234, data); List<Message> messages = response.getMessages(); MonitoringCheck result = response.getResult(); assertTrue(messages.isEmpty()); assertEquals(300, result.getCheckInterval()); assertEquals(MonitoringCheckType.HTTP, result.getCheckType()); assertTrue(result.getContactgroups().isEmpty()); assertEquals("example.com", result.getDomainname()); assertEquals(1235, result.getId()); assertEquals("188.93.14.212", result.getIp()); assertEquals(4849, result.getJiffyBox()); assertEquals("Kopie von Test", result.getName()); assertNull(result.getPassword()); assertEquals("/index.php", result.getPath()); assertEquals(80, result.getPort()); assertEquals(3600, result.getReminderInterval()); assertEquals(3, result.getRetryTolerance()); assertEquals(MonitoringCheckStatus.STATUS_CREATING, result.getStatus()); assertNull(result.getUsername()); }
/** * Test for {@link ModuleBackups#getBackup(int)}. */ @TestTemplate void testGetBackup(WireMockServer wireMock, JiffyBoxApi api) { MappingBuilder builder = get(urlPathEqualTo("/00000000000000000000000000000000/v1.0/backups/12345")); wireMock.stubFor(builder.willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/backups/testGetBackup.json"))); Response<Backup> response = api.backups().getBackup(12345); List<Message> messages = response.getMessages(); Backup backup = response.getResult(); BackupEntry daily = backup.getDaily(); BackupEntry weekly = backup.getWeekly(); BackupEntry biweekly = backup.getBiweekly(); assertTrue(messages.isEmpty()); assertEquals(1, backup.getDay()); assertEquals(1, backup.getTime()); assertEquals(1234567890, daily.getCreated()); assertEquals("1234567890abcdef1234567890abcdef", daily.getId()); assertEquals(1234567890, weekly.getCreated()); assertEquals("234567890abcdef1234567890abcdef1", weekly.getId()); assertEquals(1234567890, biweekly.getCreated()); assertEquals("34567890abcdef1234567890abcdef12", biweekly.getId()); assertNull(backup.getManual()); }
/** * Test for {@link ModuleIps#moveIPAddress(int, int, int)}. */ @TestTemplate void testMoveIPAddress(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(put(urlPathEqualTo("/00000000000000000000000000000000/v1.0/ips/12345/8465/move")) .withRequestBody(equalToJson("{\"targetid\": 4321}", false, false)) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/ips/testMoveIPAddress.json"))); Response<Boolean> response = api.ips().moveIPAddress(12345, 8465, 4321); List<Message> messages = response.getMessages(); assertTrue(messages.isEmpty()); assertTrue(response.getResult()); }
/** * Test for {@link ModuleJiffyBoxes#duplicateJiffyBox(int, String, int)}. */ @TestTemplate void testDuplicateJiffyBox1(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/jiffyBoxes/12345")) .withRequestBody(equalToJson("{\"name\": \"Test\", \"planid\": 10}")) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/jiffyBoxes/testDuplicateJiffyBox1.json"))); Response<JiffyBox> response = api.jiffyBoxes().duplicateJiffyBox(12345, "Test", 10); testDuplicateJiffyBoxResponse(response); }
/** * Test for {@link ModuleJiffyBoxes#duplicateJiffyBox(int, String, String)}. */ @TestTemplate void testDuplicateJiffyBox2(WireMockServer wireMock, JiffyBoxApi api) { wireMock.stubFor(post(urlPathEqualTo("/00000000000000000000000000000000/v1.0/jiffyBoxes/12345")) .withRequestBody(equalToJson("{\"name\": \"Test\", \"planid\": \"CloudLevel 1\"}")) .willReturn(aResponse().withHeaders(WireMockHelper.headers()) .withStatus(200) .withBodyFile("modules/jiffyBoxes/testDuplicateJiffyBox2.json"))); Response<JiffyBox> response = api.jiffyBoxes().duplicateJiffyBox(12345, "Test", "CloudLevel 1"); testDuplicateJiffyBoxResponse(response); }
@TestTemplate @UseDataProvider("generateRandomizers") public void generatedNumberShouldNotBeNull(Randomizer<?> randomizer) { // when Object randomNumber = randomizer.getRandomValue(); then(randomNumber).isNotNull(); }
@TestTemplate @UseDataProvider("generateSeededRandomizersAndTheirExpectedValues") public void shouldGenerateTheSameValueForTheSameSeed(Randomizer<?> randomizer, Object expected) { //when Object actual = randomizer.getRandomValue(); then(actual).isEqualTo(expected); }
@TestTemplate @UseDataProvider("generateRandomizers") public void generatedTimeShouldNotBeNull(Randomizer<?> randomizer) { // when Object randomNumber = randomizer.getRandomValue(); then(randomNumber).isNotNull(); }
@TestTemplate @UseDataProvider("generateCollectionRandomizers") public <T> void generatedCollectionShouldNotBeNull(Randomizer<Collection<T>> collectionRandomizer) { // when Collection<T> randomCollection = collectionRandomizer.getRandomValue(); then(randomCollection).isNotNull(); }
@TestTemplate @UseDataProvider("generateCollectionRandomizersWithSpecificSize") public <T> void generatedCollectionSizeShouldBeEqualToTheSpecifiedSize(Randomizer<Collection<T>> collectionRandomizer) { // when Collection<T> randomCollection = collectionRandomizer.getRandomValue(); then(randomCollection).hasSize(collectionSize); }