:()V" : {
+ "completeTestCount" : 0,
+ "incompleteTestCount" : 0,
+ "perMethodTestability" : "T000",
+ "perMethodOutcome" : "T000",
+ "lineNumbers" : [
+ 25,
+ 27
+ ]
+ },
+ "de.codecentric.boot.admin.client.registration.metadata.StartupDateMetadataContributor.getMetadata:()Ljava/util/Map;" : {
+ "completeTestCount" : 0,
+ "incompleteTestCount" : 0,
+ "perMethodTestability" : "T000",
+ "perMethodOutcome" : "T000",
+ "lineNumbers" : [
+ 31
+ ]
+ }
+ },
+ "validationMetrics" : { }
+}
\ No newline at end of file
diff --git a/spring-boot-admin-client/pom.xml b/spring-boot-admin-client/pom.xml
index f1d22012fa2..71c1530c078 100644
--- a/spring-boot-admin-client/pom.xml
+++ b/spring-boot-admin-client/pom.xml
@@ -81,6 +81,18 @@
${wiremock.version}
test
+
+ io.projectreactor
+ reactor-test
+ 3.7.6
+ test
+
+
+ org.junit.platform
+ junit-platform-launcher
+ 1.12.1
+ test
+
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/ClientPropertiesDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/ClientPropertiesDiffblueTest.java
new file mode 100644
index 00000000000..8e3c13285dd
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/ClientPropertiesDiffblueTest.java
@@ -0,0 +1,73 @@
+package de.codecentric.boot.admin.client.config;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.web.reactive.context.StandardReactiveWebEnvironment;
+import org.springframework.core.env.Environment;
+
+class ClientPropertiesDiffblueTest {
+
+ /**
+ * Test {@link ClientProperties#getAdminUrl()}.
+ *
+ * - Given {@link ClientProperties} (default constructor).
+ * - Then return array length is zero.
+ *
+ *
+ * Method under test: {@link ClientProperties#getAdminUrl()}
+ */
+ @Test
+ @DisplayName("Test getAdminUrl(); given ClientProperties (default constructor); then return array length is zero")
+ @Tag("MaintainedByDiffblue")
+ void testGetAdminUrl_givenClientProperties_thenReturnArrayLengthIsZero() {
+ // Arrange, Act and Assert
+ assertEquals(0, new ClientProperties().getAdminUrl().length);
+ }
+
+ /**
+ * Test {@link ClientProperties#getAdminUrl()}.
+ *
+ * - Then return array of {@link String} with
+ * {@code https://example.org/example/Api Path}.
+ *
+ *
+ * Method under test: {@link ClientProperties#getAdminUrl()}
+ */
+ @Test
+ @DisplayName("Test getAdminUrl(); then return array of String with 'https://example.org/example/Api Path'")
+ @Tag("MaintainedByDiffblue")
+ void testGetAdminUrl_thenReturnArrayOfStringWithHttpsExampleOrgExampleApiPath() {
+ // Arrange
+ ClientProperties clientProperties = new ClientProperties();
+ clientProperties.setApiPath("Api Path");
+ clientProperties.setEnabled(true);
+ clientProperties.setPassword("iloveyou");
+ clientProperties.setRegisterOnce(true);
+ clientProperties.setUrl(new String[] { "https://example.org/example" });
+ clientProperties.setUsername("janedoe");
+
+ // Act and Assert
+ assertArrayEquals(new String[] { "https://example.org/example/Api Path" }, clientProperties.getAdminUrl());
+ }
+
+ /**
+ * Test {@link ClientProperties#isAutoDeregistration(Environment)}.
+ *
+ * Method under test: {@link ClientProperties#isAutoDeregistration(Environment)}
+ */
+ @Test
+ @DisplayName("Test isAutoDeregistration(Environment)")
+ @Tag("MaintainedByDiffblue")
+ void testIsAutoDeregistration() {
+ // Arrange
+ ClientProperties clientProperties = new ClientProperties();
+
+ // Act and Assert
+ assertFalse(clientProperties.isAutoDeregistration(new StandardReactiveWebEnvironment()));
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientAutoConfigurationDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientAutoConfigurationDiffblueTest.java
new file mode 100644
index 00000000000..f632387ab3e
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientAutoConfigurationDiffblueTest.java
@@ -0,0 +1,310 @@
+package de.codecentric.boot.admin.client.config;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import de.codecentric.boot.admin.client.config.SpringBootAdminClientAutoConfiguration.BlockingRegistrationClientConfig;
+import de.codecentric.boot.admin.client.config.SpringBootAdminClientAutoConfiguration.ReactiveRegistrationClientConfig;
+import de.codecentric.boot.admin.client.registration.ApplicationFactory;
+import de.codecentric.boot.admin.client.registration.ApplicationRegistrator;
+import de.codecentric.boot.admin.client.registration.BlockingRegistrationClient;
+import de.codecentric.boot.admin.client.registration.DefaultApplicationRegistrator;
+import de.codecentric.boot.admin.client.registration.ReactiveRegistrationClient;
+import de.codecentric.boot.admin.client.registration.RegistrationClient;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.reactive.function.client.WebClient.Builder;
+
+class SpringBootAdminClientAutoConfigurationDiffblueTest {
+
+ /**
+ * Test BlockingRegistrationClientConfig
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}.
+ *
+ * Method under test:
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}
+ */
+ @Test
+ @DisplayName("Test BlockingRegistrationClientConfig registrationClient(ClientProperties)")
+ @Tag("MaintainedByDiffblue")
+ void testBlockingRegistrationClientConfigRegistrationClient() {
+ // Arrange
+ BlockingRegistrationClientConfig blockingRegistrationClientConfig = new BlockingRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername(null);
+ client.setPassword(null);
+
+ // Act and Assert
+ assertTrue(blockingRegistrationClientConfig.registrationClient(client) instanceof BlockingRegistrationClient);
+ }
+
+ /**
+ * Test BlockingRegistrationClientConfig
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}.
+ *
+ * - Given {@code Client}.
+ *
+ *
+ * Method under test:
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}
+ */
+ @Test
+ @DisplayName("Test BlockingRegistrationClientConfig registrationClient(ClientProperties); given 'Client'")
+ @Tag("MaintainedByDiffblue")
+ void testBlockingRegistrationClientConfigRegistrationClient_givenClient() {
+ // Arrange
+ BlockingRegistrationClientConfig blockingRegistrationClientConfig = new BlockingRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("Client");
+ client.setPassword(null);
+
+ // Act and Assert
+ assertTrue(blockingRegistrationClientConfig.registrationClient(client) instanceof BlockingRegistrationClient);
+ }
+
+ /**
+ * Test BlockingRegistrationClientConfig
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}.
+ *
+ * - Given {@code iloveyou}.
+ *
+ *
+ * Method under test:
+ * {@link BlockingRegistrationClientConfig#registrationClient(ClientProperties)}
+ */
+ @Test
+ @DisplayName("Test BlockingRegistrationClientConfig registrationClient(ClientProperties); given 'iloveyou'")
+ @Tag("MaintainedByDiffblue")
+ void testBlockingRegistrationClientConfigRegistrationClient_givenIloveyou() {
+ // Arrange
+ BlockingRegistrationClientConfig blockingRegistrationClientConfig = new BlockingRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword("iloveyou");
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("janedoe");
+
+ // Act and Assert
+ assertTrue(blockingRegistrationClientConfig.registrationClient(client) instanceof BlockingRegistrationClient);
+ }
+
+ /**
+ * Test ReactiveRegistrationClientConfig
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}.
+ *
+ * Method under test:
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}
+ */
+ @Test
+ @DisplayName("Test ReactiveRegistrationClientConfig registrationClient(ClientProperties, Builder)")
+ @Tag("MaintainedByDiffblue")
+ void testReactiveRegistrationClientConfigRegistrationClient() {
+ // Arrange
+ ReactiveRegistrationClientConfig reactiveRegistrationClientConfig = new ReactiveRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword(null);
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername(null);
+ Builder webClient = mock(Builder.class);
+ when(webClient.build()).thenReturn(mock(WebClient.class));
+
+ // Act
+ RegistrationClient actualRegistrationClientResult = reactiveRegistrationClientConfig.registrationClient(client,
+ webClient);
+
+ // Assert
+ verify(webClient).build();
+ assertTrue(actualRegistrationClientResult instanceof ReactiveRegistrationClient);
+ }
+
+ /**
+ * Test ReactiveRegistrationClientConfig
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}.
+ *
+ * - Given {@code null}.
+ *
+ *
+ * Method under test:
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}
+ */
+ @Test
+ @DisplayName("Test ReactiveRegistrationClientConfig registrationClient(ClientProperties, Builder); given 'null'")
+ @Tag("MaintainedByDiffblue")
+ void testReactiveRegistrationClientConfigRegistrationClient_givenNull() {
+ // Arrange
+ ReactiveRegistrationClientConfig reactiveRegistrationClientConfig = new ReactiveRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword(null);
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("janedoe");
+ Builder webClient = mock(Builder.class);
+ when(webClient.build()).thenReturn(mock(WebClient.class));
+
+ // Act
+ RegistrationClient actualRegistrationClientResult = reactiveRegistrationClientConfig.registrationClient(client,
+ webClient);
+
+ // Assert
+ verify(webClient).build();
+ assertTrue(actualRegistrationClientResult instanceof ReactiveRegistrationClient);
+ }
+
+ /**
+ * Test ReactiveRegistrationClientConfig
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}.
+ *
+ * - Then calls {@link Builder#filter(ExchangeFilterFunction)}.
+ *
+ *
+ * Method under test:
+ * {@link ReactiveRegistrationClientConfig#registrationClient(ClientProperties, Builder)}
+ */
+ @Test
+ @DisplayName("Test ReactiveRegistrationClientConfig registrationClient(ClientProperties, Builder); then calls filter(ExchangeFilterFunction)")
+ @Tag("MaintainedByDiffblue")
+ void testReactiveRegistrationClientConfigRegistrationClient_thenCallsFilter() {
+ // Arrange
+ ReactiveRegistrationClientConfig reactiveRegistrationClientConfig = new ReactiveRegistrationClientConfig();
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword("iloveyou");
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("janedoe");
+ Builder builder = mock(Builder.class);
+ when(builder.build()).thenReturn(mock(WebClient.class));
+ Builder webClient = mock(Builder.class);
+ when(webClient.filter(Mockito.any())).thenReturn(builder);
+
+ // Act
+ RegistrationClient actualRegistrationClientResult = reactiveRegistrationClientConfig.registrationClient(client,
+ webClient);
+
+ // Assert
+ verify(builder).build();
+ verify(webClient).filter(isA(ExchangeFilterFunction.class));
+ assertTrue(actualRegistrationClientResult instanceof ReactiveRegistrationClient);
+ }
+
+ /**
+ * Test
+ * {@link SpringBootAdminClientAutoConfiguration#registrator(RegistrationClient, ClientProperties, ApplicationFactory)}.
+ *
+ * - Given {@code false}.
+ * - When {@link ClientProperties} (default constructor) RegisterOnce is
+ * {@code false}.
+ *
+ *
+ * Method under test:
+ * {@link SpringBootAdminClientAutoConfiguration#registrator(RegistrationClient, ClientProperties, ApplicationFactory)}
+ */
+ @Test
+ @DisplayName("Test registrator(RegistrationClient, ClientProperties, ApplicationFactory); given 'false'; when ClientProperties (default constructor) RegisterOnce is 'false'")
+ @Tag("MaintainedByDiffblue")
+ void testRegistrator_givenFalse_whenClientPropertiesRegisterOnceIsFalse() {
+ // Arrange
+ SpringBootAdminClientAutoConfiguration springBootAdminClientAutoConfiguration = new SpringBootAdminClientAutoConfiguration();
+ BlockingRegistrationClient registrationClient = new BlockingRegistrationClient(mock(RestTemplate.class));
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword("iloveyou");
+ client.setRegisterOnce(false);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("janedoe");
+
+ // Act
+ ApplicationRegistrator actualRegistratorResult = springBootAdminClientAutoConfiguration
+ .registrator(registrationClient, client, mock(ApplicationFactory.class));
+
+ // Assert
+ assertTrue(actualRegistratorResult instanceof DefaultApplicationRegistrator);
+ assertNull(actualRegistratorResult.getRegisteredId());
+ }
+
+ /**
+ * Test
+ * {@link SpringBootAdminClientAutoConfiguration#registrator(RegistrationClient, ClientProperties, ApplicationFactory)}.
+ *
+ * - When {@link ClientProperties} (default constructor) RegisterOnce is
+ * {@code true}.
+ *
+ *
+ * Method under test:
+ * {@link SpringBootAdminClientAutoConfiguration#registrator(RegistrationClient, ClientProperties, ApplicationFactory)}
+ */
+ @Test
+ @DisplayName("Test registrator(RegistrationClient, ClientProperties, ApplicationFactory); when ClientProperties (default constructor) RegisterOnce is 'true'")
+ @Tag("MaintainedByDiffblue")
+ void testRegistrator_whenClientPropertiesRegisterOnceIsTrue() {
+ // Arrange
+ SpringBootAdminClientAutoConfiguration springBootAdminClientAutoConfiguration = new SpringBootAdminClientAutoConfiguration();
+ BlockingRegistrationClient registrationClient = new BlockingRegistrationClient(mock(RestTemplate.class));
+
+ ClientProperties client = new ClientProperties();
+ client.setApiPath("Api Path");
+ client.setEnabled(true);
+ client.setPassword("iloveyou");
+ client.setRegisterOnce(true);
+ client.setUrl(new String[] { "https://example.org/example" });
+ client.setUsername("janedoe");
+
+ // Act
+ ApplicationRegistrator actualRegistratorResult = springBootAdminClientAutoConfiguration
+ .registrator(registrationClient, client, mock(ApplicationFactory.class));
+
+ // Assert
+ assertTrue(actualRegistratorResult instanceof DefaultApplicationRegistrator);
+ assertNull(actualRegistratorResult.getRegisteredId());
+ }
+
+ /**
+ * Test
+ * {@link SpringBootAdminClientAutoConfiguration#startupDateMetadataContributor()}.
+ *
+ * Method under test:
+ * {@link SpringBootAdminClientAutoConfiguration#startupDateMetadataContributor()}
+ */
+ @Test
+ @DisplayName("Test startupDateMetadataContributor()")
+ @Tag("MaintainedByDiffblue")
+ void testStartupDateMetadataContributor() {
+ // Arrange, Act and Assert
+ assertEquals(1,
+ new SpringBootAdminClientAutoConfiguration().startupDateMetadataContributor().getMetadata().size());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientCloudFoundryAutoConfigurationDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientCloudFoundryAutoConfigurationDiffblueTest.java
new file mode 100644
index 00000000000..848c2f5cab8
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientCloudFoundryAutoConfigurationDiffblueTest.java
@@ -0,0 +1,42 @@
+package de.codecentric.boot.admin.client.config;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import java.util.ArrayList;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+class SpringBootAdminClientCloudFoundryAutoConfigurationDiffblueTest {
+
+ /**
+ * Test
+ * {@link SpringBootAdminClientCloudFoundryAutoConfiguration#cloudFoundryMetadataContributor(CloudFoundryApplicationProperties)}.
+ *
+ * Method under test:
+ * {@link SpringBootAdminClientCloudFoundryAutoConfiguration#cloudFoundryMetadataContributor(CloudFoundryApplicationProperties)}
+ */
+ @Test
+ @DisplayName("Test cloudFoundryMetadataContributor(CloudFoundryApplicationProperties)")
+ @Tag("MaintainedByDiffblue")
+ void testCloudFoundryMetadataContributor() {
+ // Arrange
+ SpringBootAdminClientCloudFoundryAutoConfiguration springBootAdminClientCloudFoundryAutoConfiguration = new SpringBootAdminClientCloudFoundryAutoConfiguration();
+
+ CloudFoundryApplicationProperties cloudFoundryApplicationProperties = new CloudFoundryApplicationProperties();
+ cloudFoundryApplicationProperties.setApplicationId("42");
+ cloudFoundryApplicationProperties.setInstanceIndex("Instance Index");
+ cloudFoundryApplicationProperties.setUris(new ArrayList<>());
+
+ // Act
+ Map actualMetadata = springBootAdminClientCloudFoundryAutoConfiguration
+ .cloudFoundryMetadataContributor(cloudFoundryApplicationProperties)
+ .getMetadata();
+
+ // Assert
+ assertEquals(2, actualMetadata.size());
+ assertEquals("42", actualMetadata.get("applicationId"));
+ assertEquals("Instance Index", actualMetadata.get("instanceId"));
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientEnabledConditionDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientEnabledConditionDiffblueTest.java
new file mode 100644
index 00000000000..b68f49ae875
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/config/SpringBootAdminClientEnabledConditionDiffblueTest.java
@@ -0,0 +1,46 @@
+package de.codecentric.boot.admin.client.config;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
+import org.springframework.boot.web.reactive.context.StandardReactiveWebEnvironment;
+import org.springframework.context.annotation.ConditionContext;
+import org.springframework.core.type.AnnotatedTypeMetadata;
+
+class SpringBootAdminClientEnabledConditionDiffblueTest {
+
+ /**
+ * Test
+ * {@link SpringBootAdminClientEnabledCondition#getMatchOutcome(ConditionContext, AnnotatedTypeMetadata)}.
+ *
+ * Method under test:
+ * {@link SpringBootAdminClientEnabledCondition#getMatchOutcome(ConditionContext, AnnotatedTypeMetadata)}
+ */
+ @Test
+ @DisplayName("Test getMatchOutcome(ConditionContext, AnnotatedTypeMetadata)")
+ @Tag("MaintainedByDiffblue")
+ void testGetMatchOutcome() {
+ // Arrange
+ SpringBootAdminClientEnabledCondition springBootAdminClientEnabledCondition = new SpringBootAdminClientEnabledCondition();
+ ConditionContext context = mock(ConditionContext.class);
+ when(context.getEnvironment()).thenReturn(new StandardReactiveWebEnvironment());
+
+ // Act
+ ConditionOutcome actualMatchOutcome = springBootAdminClientEnabledCondition.getMatchOutcome(context,
+ mock(AnnotatedTypeMetadata.class));
+
+ // Assert
+ verify(context).getEnvironment();
+ assertEquals("Spring Boot Client is disabled, because 'spring.boot.admin.client.url' is empty.",
+ actualMatchOutcome.getMessage());
+ assertFalse(actualMatchOutcome.getConditionMessage().isEmpty());
+ assertFalse(actualMatchOutcome.isMatch());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/ApplicationDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/ApplicationDiffblueTest.java
new file mode 100644
index 00000000000..6d0f55818ff
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/ApplicationDiffblueTest.java
@@ -0,0 +1,55 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+class ApplicationDiffblueTest {
+
+ /**
+ * Test {@link Application#Application(String, String, String, String, Map)}.
+ *
+ * - When {@code Name}.
+ * - Then return {@code Name}.
+ *
+ *
+ * Method under test:
+ * {@link Application#Application(String, String, String, String, Map)}
+ */
+ @Test
+ @DisplayName("Test new Application(String, String, String, String, Map); when 'Name'; then return 'Name'")
+ @Tag("MaintainedByDiffblue")
+ void testNewApplication_whenName_thenReturnName() {
+ // Arrange and Act
+ Application actualApplication = new Application("Name", "https://example.org/example",
+ "https://example.org/example", "https://example.org/example", new HashMap<>());
+
+ // Assert
+ assertEquals("Name", actualApplication.getName());
+ assertEquals("https://example.org/example", actualApplication.getHealthUrl());
+ assertEquals("https://example.org/example", actualApplication.getManagementUrl());
+ assertEquals("https://example.org/example", actualApplication.getServiceUrl());
+ assertTrue(actualApplication.getMetadata().isEmpty());
+ }
+
+ /**
+ * Test {@link Application#getMetadata()}.
+ *
+ * Method under test: {@link Application#getMetadata()}
+ */
+ @Test
+ @DisplayName("Test getMetadata()")
+ @Tag("MaintainedByDiffblue")
+ void testGetMetadata() {
+ // Arrange, Act and Assert
+ assertTrue(new Application("Name", "https://example.org/example", "https://example.org/example",
+ "https://example.org/example", new HashMap<>())
+ .getMetadata()
+ .isEmpty());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/BlockingRegistrationClientDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/BlockingRegistrationClientDiffblueTest.java
new file mode 100644
index 00000000000..680c8c56b4c
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/BlockingRegistrationClientDiffblueTest.java
@@ -0,0 +1,73 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.aot.DisabledInAotMode;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestTemplate;
+
+@ContextConfiguration(classes = { BlockingRegistrationClient.class })
+@DisabledInAotMode
+@ExtendWith(SpringExtension.class)
+class BlockingRegistrationClientDiffblueTest {
+
+ @Autowired
+ private BlockingRegistrationClient blockingRegistrationClient;
+
+ @MockitoBean
+ private RestTemplate restTemplate;
+
+ /**
+ * Test {@link BlockingRegistrationClient#deregister(String, String)}.
+ *
+ * Method under test: {@link BlockingRegistrationClient#deregister(String, String)}
+ */
+ @Test
+ @DisplayName("Test deregister(String, String)")
+ @Tag("MaintainedByDiffblue")
+ void testDeregister() throws RestClientException {
+ // Arrange
+ doNothing().when(restTemplate).delete(Mockito.any(), isA(Object[].class));
+
+ // Act
+ blockingRegistrationClient.deregister("https://example.org/example", "42");
+
+ // Assert
+ verify(restTemplate).delete(eq("https://example.org/example/42"), isA(Object[].class));
+ }
+
+ /**
+ * Test {@link BlockingRegistrationClient#createRequestHeaders()}.
+ *
+ * Method under test: {@link BlockingRegistrationClient#createRequestHeaders()}
+ */
+ @Test
+ @DisplayName("Test createRequestHeaders()")
+ @Tag("MaintainedByDiffblue")
+ void testCreateRequestHeaders() {
+ // Arrange and Act
+ HttpHeaders actualCreateRequestHeadersResult = blockingRegistrationClient.createRequestHeaders();
+
+ // Assert
+ assertEquals(2, actualCreateRequestHeadersResult.size());
+ List getResult = actualCreateRequestHeadersResult.get(HttpHeaders.CONTENT_TYPE);
+ assertEquals(1, getResult.size());
+ assertEquals("application/json", getResult.get(0));
+ assertEquals(getResult, actualCreateRequestHeadersResult.get(HttpHeaders.ACCEPT));
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/CloudFoundryApplicationFactoryDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/CloudFoundryApplicationFactoryDiffblueTest.java
new file mode 100644
index 00000000000..121037dd2e3
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/CloudFoundryApplicationFactoryDiffblueTest.java
@@ -0,0 +1,129 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import de.codecentric.boot.admin.client.config.CloudFoundryApplicationProperties;
+import de.codecentric.boot.admin.client.config.InstanceProperties;
+import de.codecentric.boot.admin.client.config.ServiceHostType;
+import de.codecentric.boot.admin.client.registration.metadata.MetadataContributor;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.web.server.ManagementServerProperties;
+import org.springframework.boot.actuate.endpoint.web.PathMappedEndpoints;
+import org.springframework.boot.autoconfigure.web.ServerProperties;
+import org.springframework.boot.autoconfigure.web.ServerProperties.ForwardHeadersStrategy;
+import org.springframework.boot.web.server.Shutdown;
+import org.springframework.boot.web.server.Ssl;
+import org.springframework.boot.web.server.Ssl.ClientAuth;
+import org.springframework.util.unit.DataSize;
+
+class CloudFoundryApplicationFactoryDiffblueTest {
+
+ /**
+ * Test {@link CloudFoundryApplicationFactory#getServiceBaseUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link CloudFoundryApplicationFactory#getServiceBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceBaseUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceBaseUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ CloudFoundryApplicationProperties cfApplicationProperties = new CloudFoundryApplicationProperties();
+ cfApplicationProperties.setApplicationId("42");
+ cfApplicationProperties.setInstanceIndex("Instance Index");
+ cfApplicationProperties.setUris(new ArrayList<>());
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new CloudFoundryApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class), cfApplicationProperties)
+ .getServiceBaseUrl());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationFactoryDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationFactoryDiffblueTest.java
new file mode 100644
index 00000000000..8e75e34d85f
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationFactoryDiffblueTest.java
@@ -0,0 +1,2234 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import de.codecentric.boot.admin.client.config.InstanceProperties;
+import de.codecentric.boot.admin.client.config.ServiceHostType;
+import de.codecentric.boot.admin.client.registration.metadata.MetadataContributor;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.web.server.ManagementServerProperties;
+import org.springframework.boot.actuate.endpoint.web.PathMappedEndpoints;
+import org.springframework.boot.autoconfigure.web.ServerProperties;
+import org.springframework.boot.autoconfigure.web.ServerProperties.ForwardHeadersStrategy;
+import org.springframework.boot.web.server.Shutdown;
+import org.springframework.boot.web.server.Ssl;
+import org.springframework.boot.web.server.Ssl.ClientAuth;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.aot.DisabledInAotMode;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.util.unit.DataSize;
+
+@ContextConfiguration(classes = { DefaultApplicationFactory.class, InstanceProperties.class,
+ ManagementServerProperties.class, ServerProperties.class, WebEndpointProperties.class })
+@DisabledInAotMode
+@ExtendWith(SpringExtension.class)
+class DefaultApplicationFactoryDiffblueTest {
+
+ @Autowired
+ private DefaultApplicationFactory defaultApplicationFactory;
+
+ @Autowired
+ private InstanceProperties instanceProperties;
+
+ @Autowired
+ private ManagementServerProperties managementServerProperties;
+
+ @MockitoBean
+ private MetadataContributor metadataContributor;
+
+ @MockitoBean
+ private PathMappedEndpoints pathMappedEndpoints;
+
+ @Autowired
+ private ServerProperties serverProperties;
+
+ @Autowired
+ private WebEndpointProperties webEndpointProperties;
+
+ /**
+ * Test {@link DefaultApplicationFactory#createApplication()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#createApplication()}
+ */
+ @Test
+ @DisplayName("Test createApplication(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testCreateApplication_thenThrowIllegalStateException() {
+ // Arrange, Act and Assert
+ assertThrows(IllegalStateException.class, () -> defaultApplicationFactory.createApplication());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getName()}.
+ *
+ * - Given {@link WebEndpointProperties} (default constructor) BasePath is empty
+ * string.
+ * - Then return {@code Name}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getName()}
+ */
+ @Test
+ @DisplayName("Test getName(); given WebEndpointProperties (default constructor) BasePath is empty string; then return 'Name'")
+ @Tag("MaintainedByDiffblue")
+ void testGetName_givenWebEndpointPropertiesBasePathIsEmptyString_thenReturnName() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("Name",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getName());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceUrl()}.
+ *
+ * - Then return {@code https://example.org/exampleService%20Path}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceUrl(); then return 'https://example.org/exampleService%20Path'")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceUrl_thenReturnHttpsExampleOrgExampleService20Path() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl(null);
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/exampleService%20Path",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceBaseUrl()}.
+ *
+ * - Given {@link InstanceProperties} (default constructor) PreferIp is
+ * {@code false}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceBaseUrl(); given InstanceProperties (default constructor) PreferIp is 'false'")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceBaseUrl_givenInstancePropertiesPreferIpIsFalse() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(false);
+ instance.setServiceBaseUrl("");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+ InetAddress address = mock(InetAddress.class);
+ when(address.getHostAddress()).thenReturn("42 Main St");
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(address);
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceBaseUrl());
+ verify(address).getHostAddress();
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceBaseUrl()}.
+ *
+ * - Given {@link Ssl} (default constructor) Enabled is {@code false}.
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceBaseUrl(); given Ssl (default constructor) Enabled is 'false'; then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceBaseUrl_givenSslEnabledIsFalse_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+ InetAddress address = mock(InetAddress.class);
+ when(address.getHostAddress()).thenReturn("42 Main St");
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(false);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(address);
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceBaseUrl());
+ verify(address).getHostAddress();
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceBaseUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceBaseUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceBaseUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceBaseUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getServiceBaseUrl()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getServiceBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getServiceBaseUrl(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetServiceBaseUrl_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+ InetAddress address = mock(InetAddress.class);
+ when(address.getHostAddress()).thenReturn("42 Main St");
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(address);
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getServiceBaseUrl());
+ verify(address).getHostAddress();
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getManagementUrl()}.
+ *
+ * - Given {@link InstanceProperties} (default constructor) ManagementBaseUrl is
+ * {@code null}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getManagementUrl()}
+ */
+ @Test
+ @DisplayName("Test getManagementUrl(); given InstanceProperties (default constructor) ManagementBaseUrl is 'null'")
+ @Tag("MaintainedByDiffblue")
+ void testGetManagementUrl_givenInstancePropertiesManagementBaseUrlIsNull() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl(null);
+ instance.setManagementUrl(null);
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example/",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getManagementUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getManagementUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getManagementUrl()}
+ */
+ @Test
+ @DisplayName("Test getManagementUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetManagementUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getManagementUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getManagementUrl()}.
+ *
+ * - Then return {@code https://example.org/example/}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getManagementUrl()}
+ */
+ @Test
+ @DisplayName("Test getManagementUrl(); then return 'https://example.org/example/'")
+ @Tag("MaintainedByDiffblue")
+ void testGetManagementUrl_thenReturnHttpsExampleOrgExample2() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl(null);
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example/",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getManagementUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getManagementBaseUrl()}.
+ *
+ * - Given {@link InstanceProperties} (default constructor) ManagementBaseUrl is
+ * empty string.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getManagementBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getManagementBaseUrl(); given InstanceProperties (default constructor) ManagementBaseUrl is empty string")
+ @Tag("MaintainedByDiffblue")
+ void testGetManagementBaseUrl_givenInstancePropertiesManagementBaseUrlIsEmptyString() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getManagementBaseUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getManagementBaseUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getManagementBaseUrl()}
+ */
+ @Test
+ @DisplayName("Test getManagementBaseUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetManagementBaseUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getManagementBaseUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#isManagementPortEqual()}.
+ *
+ * - Then return {@code true}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#isManagementPortEqual()}
+ */
+ @Test
+ @DisplayName("Test isManagementPortEqual(); then return 'true'")
+ @Tag("MaintainedByDiffblue")
+ void testIsManagementPortEqual_thenReturnTrue() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertTrue(new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint, mock(MetadataContributor.class))
+ .isManagementPortEqual());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getEndpointsWebPath()}.
+ *
+ * - Then return empty string.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getEndpointsWebPath()}
+ */
+ @Test
+ @DisplayName("Test getEndpointsWebPath(); then return empty string")
+ @Tag("MaintainedByDiffblue")
+ void testGetEndpointsWebPath_thenReturnEmptyString() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getEndpointsWebPath());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getHealthUrl()}.
+ *
+ * - Given {@link InstanceProperties} (default constructor) ManagementBaseUrl is
+ * {@code null}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getHealthUrl()}
+ */
+ @Test
+ @DisplayName("Test getHealthUrl(); given InstanceProperties (default constructor) ManagementBaseUrl is 'null'")
+ @Tag("MaintainedByDiffblue")
+ void testGetHealthUrl_givenInstancePropertiesManagementBaseUrlIsNull() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl(null);
+ instance.setManagementBaseUrl(null);
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getHealthUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getHealthUrl()}.
+ *
+ * - Then return {@code https://example.org/example}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getHealthUrl()}
+ */
+ @Test
+ @DisplayName("Test getHealthUrl(); then return 'https://example.org/example'")
+ @Tag("MaintainedByDiffblue")
+ void testGetHealthUrl_thenReturnHttpsExampleOrgExample() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertEquals("https://example.org/example",
+ new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getHealthUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getHealthUrl()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getHealthUrl()}
+ */
+ @Test
+ @DisplayName("Test getHealthUrl(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetHealthUrl_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl(null);
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getHealthUrl());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getMetadata()}.
+ *
+ * - Given {@link MetadataContributor} {@link MetadataContributor#getMetadata()}
+ * return {@link HashMap#HashMap()}.
+ * - Then return Empty.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getMetadata()}
+ */
+ @Test
+ @DisplayName("Test getMetadata(); given MetadataContributor getMetadata() return HashMap(); then return Empty")
+ @Tag("MaintainedByDiffblue")
+ void testGetMetadata_givenMetadataContributorGetMetadataReturnHashMap_thenReturnEmpty() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+ MetadataContributor metadataContributor = mock(MetadataContributor.class);
+ when(metadataContributor.getMetadata()).thenReturn(new HashMap<>());
+
+ // Act
+ Map actualMetadata = new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint, metadataContributor)
+ .getMetadata();
+
+ // Assert
+ verify(metadataContributor).getMetadata();
+ assertTrue(actualMetadata.isEmpty());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getMetadata()}.
+ *
+ * - Then throw {@link IllegalArgumentException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getMetadata()}
+ */
+ @Test
+ @DisplayName("Test getMetadata(); then throw IllegalArgumentException")
+ @Tag("MaintainedByDiffblue")
+ void testGetMetadata_thenThrowIllegalArgumentException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+ MetadataContributor metadataContributor = mock(MetadataContributor.class);
+ when(metadataContributor.getMetadata()).thenThrow(new IllegalArgumentException("foo"));
+
+ // Act and Assert
+ assertThrows(IllegalArgumentException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint, metadataContributor)
+ .getMetadata());
+ verify(metadataContributor).getMetadata();
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getLocalServerPort()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getLocalServerPort()}
+ */
+ @Test
+ @DisplayName("Test getLocalServerPort(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetLocalServerPort_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getLocalServerPort());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getLocalManagementPort()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getLocalManagementPort()}
+ */
+ @Test
+ @DisplayName("Test getLocalManagementPort(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetLocalManagementPort_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getLocalManagementPort());
+ }
+
+ /**
+ * Test {@link DefaultApplicationFactory#getHealthEndpointPath()}.
+ *
+ * - Then throw {@link IllegalStateException}.
+ *
+ *
+ * Method under test: {@link DefaultApplicationFactory#getHealthEndpointPath()}
+ */
+ @Test
+ @DisplayName("Test getHealthEndpointPath(); then throw IllegalStateException")
+ @Tag("MaintainedByDiffblue")
+ void testGetHealthEndpointPath_thenThrowIllegalStateException() {
+ // Arrange
+ InstanceProperties instance = new InstanceProperties();
+ instance.setHealthUrl("https://example.org/example");
+ instance.setManagementBaseUrl("https://example.org/example");
+ instance.setManagementUrl("https://example.org/example");
+ instance.setMetadata(new HashMap<>());
+ instance.setName("Name");
+ instance.setPreferIp(true);
+ instance.setServiceBaseUrl("https://example.org/example");
+ instance.setServiceHostType(ServiceHostType.IP);
+ instance.setServicePath("Service Path");
+ instance.setServiceUrl("https://example.org/example");
+
+ Ssl ssl = new Ssl();
+ ssl.setBundle("Bundle");
+ ssl.setCertificate("Certificate");
+ ssl.setCertificatePrivateKey("Certificate Private Key");
+ ssl.setCiphers(new String[] { "Ciphers" });
+ ssl.setClientAuth(ClientAuth.NONE);
+ ssl.setEnabled(true);
+ ssl.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl.setKeyAlias("Key Alias");
+ ssl.setKeyPassword("iloveyou");
+ ssl.setKeyStore("Key Store");
+ ssl.setKeyStorePassword("iloveyou");
+ ssl.setKeyStoreProvider("Key Store Provider");
+ ssl.setKeyStoreType("Key Store Type");
+ ssl.setProtocol("Protocol");
+ ssl.setServerNameBundles(new ArrayList<>());
+ ssl.setTrustCertificate("Trust Certificate");
+ ssl.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl.setTrustStore("Trust Store");
+ ssl.setTrustStorePassword("iloveyou");
+ ssl.setTrustStoreProvider("Trust Store Provider");
+ ssl.setTrustStoreType("Trust Store Type");
+
+ ManagementServerProperties management = new ManagementServerProperties();
+ management.setAddress(mock(InetAddress.class));
+ management.setBasePath("Base Path");
+ management.setPort(8080);
+ management.setSsl(ssl);
+
+ Ssl ssl2 = new Ssl();
+ ssl2.setBundle("Bundle");
+ ssl2.setCertificate("Certificate");
+ ssl2.setCertificatePrivateKey("Certificate Private Key");
+ ssl2.setCiphers(new String[] { "Ciphers" });
+ ssl2.setClientAuth(ClientAuth.NONE);
+ ssl2.setEnabled(true);
+ ssl2.setEnabledProtocols(new String[] { "Enabled Protocols" });
+ ssl2.setKeyAlias("Key Alias");
+ ssl2.setKeyPassword("iloveyou");
+ ssl2.setKeyStore("Key Store");
+ ssl2.setKeyStorePassword("iloveyou");
+ ssl2.setKeyStoreProvider("Key Store Provider");
+ ssl2.setKeyStoreType("Key Store Type");
+ ssl2.setProtocol("Protocol");
+ ssl2.setServerNameBundles(new ArrayList<>());
+ ssl2.setTrustCertificate("Trust Certificate");
+ ssl2.setTrustCertificatePrivateKey("Trust Certificate Private Key");
+ ssl2.setTrustStore("Trust Store");
+ ssl2.setTrustStorePassword("iloveyou");
+ ssl2.setTrustStoreProvider("Trust Store Provider");
+ ssl2.setTrustStoreType("Trust Store Type");
+
+ ServerProperties server = new ServerProperties();
+ server.setAddress(mock(InetAddress.class));
+ server.setForwardHeadersStrategy(ForwardHeadersStrategy.NATIVE);
+ server.setMaxHttpRequestHeaderSize(DataSize.ofBytes(1L));
+ server.setPort(8080);
+ server.setServerHeader("Server Header");
+ server.setShutdown(Shutdown.GRACEFUL);
+ server.setSsl(ssl2);
+
+ WebEndpointProperties webEndpoint = new WebEndpointProperties();
+ webEndpoint.setBasePath("");
+
+ // Act and Assert
+ assertThrows(IllegalStateException.class,
+ () -> new DefaultApplicationFactory(instance, management, server,
+ new PathMappedEndpoints("Base Path", new ArrayList<>()), webEndpoint,
+ mock(MetadataContributor.class))
+ .getHealthEndpointPath());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationRegistratorDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationRegistratorDiffblueTest.java
new file mode 100644
index 00000000000..f8802d34239
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/DefaultApplicationRegistratorDiffblueTest.java
@@ -0,0 +1,336 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.HashMap;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestTemplate;
+
+class DefaultApplicationRegistratorDiffblueTest {
+
+ /**
+ * Test
+ * {@link DefaultApplicationRegistrator#DefaultApplicationRegistrator(ApplicationFactory, RegistrationClient, String[], boolean)}.
+ *
+ * Method under test:
+ * {@link DefaultApplicationRegistrator#DefaultApplicationRegistrator(ApplicationFactory, RegistrationClient, String[], boolean)}
+ */
+ @Test
+ @DisplayName("Test new DefaultApplicationRegistrator(ApplicationFactory, RegistrationClient, String[], boolean)")
+ @Tag("MaintainedByDiffblue")
+ void testNewDefaultApplicationRegistrator() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+
+ // Act and Assert
+ assertNull(new DefaultApplicationRegistrator(applicationFactory,
+ new BlockingRegistrationClient(mock(RestTemplate.class)),
+ new String[] { "https://example.org/example" }, true)
+ .getRegisteredId());
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#register()}
+ */
+ @Test
+ @DisplayName("Test register()")
+ @Tag("MaintainedByDiffblue")
+ void testRegister() throws RestClientException {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ Application buildResult = Application.builder()
+ .healthUrl("https://example.org/example")
+ .managementUrl("https://example.org/example")
+ .name("Name")
+ .serviceUrl("https://example.org/example")
+ .build();
+ when(applicationFactory.createApplication()).thenReturn(buildResult);
+ RestTemplate restTemplate = mock(RestTemplate.class);
+ when(restTemplate.exchange(Mockito.any(), Mockito.any(), Mockito.>any(),
+ Mockito.>any(), isA(Object[].class)))
+ .thenReturn(new ResponseEntity<>(HttpStatus.OK));
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ applicationFactory, new BlockingRegistrationClient(restTemplate),
+ new String[] { "https://example.org/example" }, true);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator.register();
+
+ // Assert
+ verify(applicationFactory).createApplication();
+ verify(restTemplate).exchange(eq("https://example.org/example"), isA(HttpMethod.class), isA(HttpEntity.class),
+ isA(ParameterizedTypeReference.class), isA(Object[].class));
+ assertNull(defaultApplicationRegistrator.getRegisteredId());
+ assertFalse(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#register()}
+ */
+ @Test
+ @DisplayName("Test register()")
+ @Tag("MaintainedByDiffblue")
+ void testRegister2() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ Application buildResult = Application.builder()
+ .healthUrl("https://example.org/example")
+ .managementUrl("https://example.org/example")
+ .name("Name")
+ .serviceUrl("https://example.org/example")
+ .build();
+ when(applicationFactory.createApplication()).thenReturn(buildResult);
+ RegistrationClient registrationClient = mock(RegistrationClient.class);
+ when(registrationClient.register(Mockito.any(), Mockito.any())).thenReturn("Register");
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ applicationFactory, registrationClient, new String[] { "https://example.org/example" }, true);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator.register();
+
+ // Assert
+ verify(applicationFactory).createApplication();
+ verify(registrationClient).register(eq("https://example.org/example"), isA(Application.class));
+ assertEquals("Register", defaultApplicationRegistrator.getRegisteredId());
+ assertTrue(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#register()}
+ */
+ @Test
+ @DisplayName("Test register()")
+ @Tag("MaintainedByDiffblue")
+ void testRegister3() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ Application buildResult = Application.builder()
+ .healthUrl("https://example.org/example")
+ .managementUrl("https://example.org/example")
+ .name("Name")
+ .serviceUrl("https://example.org/example")
+ .build();
+ when(applicationFactory.createApplication()).thenReturn(buildResult);
+ RegistrationClient registrationClient = mock(RegistrationClient.class);
+ when(registrationClient.register(Mockito.any(), Mockito.any())).thenReturn("Register");
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ applicationFactory, registrationClient, new String[] { "https://example.org/example" }, false);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator.register();
+
+ // Assert
+ verify(applicationFactory).createApplication();
+ verify(registrationClient).register(eq("https://example.org/example"), isA(Application.class));
+ assertEquals("Register", defaultApplicationRegistrator.getRegisteredId());
+ assertTrue(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#register()}
+ */
+ @Test
+ @DisplayName("Test register()")
+ @Tag("MaintainedByDiffblue")
+ void testRegister4() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ Application buildResult = Application.builder()
+ .healthUrl("https://example.org/example")
+ .managementUrl("https://example.org/example")
+ .name("Name")
+ .serviceUrl("https://example.org/example")
+ .build();
+ when(applicationFactory.createApplication()).thenReturn(buildResult);
+ RegistrationClient registrationClient = mock(RegistrationClient.class);
+ when(registrationClient.register(Mockito.any(), Mockito.any())).thenReturn("Register");
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ applicationFactory, registrationClient,
+ new String[] { "https://example.org/example", "Application registered itself as {}" }, false);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator.register();
+
+ // Assert
+ verify(applicationFactory).createApplication();
+ verify(registrationClient, atLeast(1)).register(Mockito.any(), isA(Application.class));
+ assertEquals("Register", defaultApplicationRegistrator.getRegisteredId());
+ assertTrue(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#register()}
+ */
+ @Test
+ @DisplayName("Test register()")
+ @Tag("MaintainedByDiffblue")
+ void testRegister5() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ Application buildResult = Application.builder()
+ .healthUrl("https://example.org/example")
+ .managementUrl("https://example.org/example")
+ .name("Name")
+ .serviceUrl("https://example.org/example")
+ .build();
+ when(applicationFactory.createApplication()).thenReturn(buildResult);
+ RegistrationClient registrationClient = mock(RegistrationClient.class);
+ when(registrationClient.register(Mockito.any(), Mockito.any())).thenReturn("Register");
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ applicationFactory, registrationClient, new String[] { "https://example.org/example",
+ "Application registered itself as {}", "https://example.org/example" },
+ false);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator.register();
+
+ // Assert
+ verify(applicationFactory).createApplication();
+ verify(registrationClient, atLeast(1)).register(Mockito.any(), isA(Application.class));
+ assertEquals("Register", defaultApplicationRegistrator.getRegisteredId());
+ assertTrue(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ * with {@code Application}, {@code String}, {@code boolean}.
+ *
+ * Method under test:
+ * {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ */
+ @Test
+ @DisplayName("Test register(Application, String, boolean) with 'Application', 'String', 'boolean'")
+ @Tag("MaintainedByDiffblue")
+ void testRegisterWithApplicationStringBoolean() throws RestClientException {
+ // Arrange
+ RestTemplate restTemplate = mock(RestTemplate.class);
+ when(restTemplate.exchange(Mockito.any(), Mockito.any(), Mockito.>any(),
+ Mockito.>any(), isA(Object[].class)))
+ .thenReturn(new ResponseEntity<>(HttpStatus.OK));
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ mock(ApplicationFactory.class), new BlockingRegistrationClient(restTemplate),
+ new String[] { "https://example.org/example" }, true);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator
+ .register(new Application("Name", "https://example.org/example", "https://example.org/example",
+ "https://example.org/example", new HashMap<>()), "https://example.org/example", true);
+
+ // Assert
+ verify(restTemplate).exchange(eq("https://example.org/example"), isA(HttpMethod.class), isA(HttpEntity.class),
+ isA(ParameterizedTypeReference.class), isA(Object[].class));
+ assertNull(defaultApplicationRegistrator.getRegisteredId());
+ assertFalse(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ * with {@code Application}, {@code String}, {@code boolean}.
+ *
+ * Method under test:
+ * {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ */
+ @Test
+ @DisplayName("Test register(Application, String, boolean) with 'Application', 'String', 'boolean'")
+ @Tag("MaintainedByDiffblue")
+ void testRegisterWithApplicationStringBoolean2() {
+ // Arrange
+ RegistrationClient registrationClient = mock(RegistrationClient.class);
+ when(registrationClient.register(Mockito.any(), Mockito.any())).thenReturn("Register");
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ mock(ApplicationFactory.class), registrationClient, new String[] { "https://example.org/example" },
+ true);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator
+ .register(new Application("Name", "https://example.org/example", "https://example.org/example",
+ "https://example.org/example", new HashMap<>()), "https://example.org/example", true);
+
+ // Assert
+ verify(registrationClient).register(eq("https://example.org/example"), isA(Application.class));
+ assertEquals("Register", defaultApplicationRegistrator.getRegisteredId());
+ assertTrue(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ * with {@code Application}, {@code String}, {@code boolean}.
+ *
+ * - When {@code false}.
+ *
+ *
+ * Method under test:
+ * {@link DefaultApplicationRegistrator#register(Application, String, boolean)}
+ */
+ @Test
+ @DisplayName("Test register(Application, String, boolean) with 'Application', 'String', 'boolean'; when 'false'")
+ @Tag("MaintainedByDiffblue")
+ void testRegisterWithApplicationStringBoolean_whenFalse() throws RestClientException {
+ // Arrange
+ RestTemplate restTemplate = mock(RestTemplate.class);
+ when(restTemplate.exchange(Mockito.any(), Mockito.any(), Mockito.>any(),
+ Mockito.>any(), isA(Object[].class)))
+ .thenReturn(new ResponseEntity<>(HttpStatus.OK));
+ DefaultApplicationRegistrator defaultApplicationRegistrator = new DefaultApplicationRegistrator(
+ mock(ApplicationFactory.class), new BlockingRegistrationClient(restTemplate),
+ new String[] { "https://example.org/example" }, true);
+
+ // Act
+ boolean actualRegisterResult = defaultApplicationRegistrator
+ .register(new Application("Name", "https://example.org/example", "https://example.org/example",
+ "https://example.org/example", new HashMap<>()), "https://example.org/example", false);
+
+ // Assert
+ verify(restTemplate).exchange(eq("https://example.org/example"), isA(HttpMethod.class), isA(HttpEntity.class),
+ isA(ParameterizedTypeReference.class), isA(Object[].class));
+ assertNull(defaultApplicationRegistrator.getRegisteredId());
+ assertFalse(actualRegisterResult);
+ }
+
+ /**
+ * Test {@link DefaultApplicationRegistrator#getRegisteredId()}.
+ *
+ * Method under test: {@link DefaultApplicationRegistrator#getRegisteredId()}
+ */
+ @Test
+ @DisplayName("Test getRegisteredId()")
+ @Tag("MaintainedByDiffblue")
+ void testGetRegisteredId() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+
+ // Act and Assert
+ assertNull(new DefaultApplicationRegistrator(applicationFactory,
+ new BlockingRegistrationClient(mock(RestTemplate.class)),
+ new String[] { "https://example.org/example" }, true)
+ .getRegisteredId());
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RegistrationApplicationListenerDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RegistrationApplicationListenerDiffblueTest.java
new file mode 100644
index 00000000000..b6b17f64895
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RegistrationApplicationListenerDiffblueTest.java
@@ -0,0 +1,47 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.event.ContextClosedEvent;
+import org.springframework.context.support.AbstractApplicationContext;
+import org.springframework.web.client.RestTemplate;
+
+class RegistrationApplicationListenerDiffblueTest {
+
+ /**
+ * Test {@link RegistrationApplicationListener#onClosedContext(ContextClosedEvent)}.
+ *
+ * - Then calls {@link AbstractApplicationContext#getParent()}.
+ *
+ *
+ * Method under test:
+ * {@link RegistrationApplicationListener#onClosedContext(ContextClosedEvent)}
+ */
+ @Test
+ @DisplayName("Test onClosedContext(ContextClosedEvent); then calls getParent()")
+ @Tag("MaintainedByDiffblue")
+ void testOnClosedContext_thenCallsGetParent() {
+ // Arrange
+ ApplicationFactory applicationFactory = mock(ApplicationFactory.class);
+ RegistrationApplicationListener registrationApplicationListener = new RegistrationApplicationListener(
+ new DefaultApplicationRegistrator(applicationFactory,
+ new BlockingRegistrationClient(mock(RestTemplate.class)),
+ new String[] { "https://example.org/example" }, true));
+ AnnotationConfigApplicationContext source = mock(AnnotationConfigApplicationContext.class);
+ when(source.getParent()).thenReturn(new AnnotationConfigReactiveWebApplicationContext());
+
+ // Act
+ registrationApplicationListener.onClosedContext(new ContextClosedEvent(source));
+
+ // Assert
+ verify(source, atLeast(1)).getParent();
+ }
+
+}
diff --git a/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RestClientRegistrationClientDiffblueTest.java b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RestClientRegistrationClientDiffblueTest.java
new file mode 100644
index 00000000000..8962c71bde0
--- /dev/null
+++ b/spring-boot-admin-client/src/test/java/de/codecentric/boot/admin/client/registration/RestClientRegistrationClientDiffblueTest.java
@@ -0,0 +1,110 @@
+package de.codecentric.boot.admin.client.registration;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpHeaders;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.aot.DisabledInAotMode;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.RestClient.RequestBodySpec;
+import org.springframework.web.client.RestClient.RequestBodyUriSpec;
+import org.springframework.web.client.RestClient.ResponseSpec;
+
+@ContextConfiguration(classes = { RestClientRegistrationClient.class })
+@DisabledInAotMode
+@ExtendWith(SpringExtension.class)
+class RestClientRegistrationClientDiffblueTest {
+
+ @MockitoBean
+ private RestClient restClient;
+
+ @Autowired
+ private RestClientRegistrationClient restClientRegistrationClient;
+
+ /**
+ * Test {@link RestClientRegistrationClient#register(String, Application)}.
+ *
+ * - Given {@link HashMap#HashMap()} {@code id} is {@code 42}.
+ * - Then return {@code 42}.
+ *
+ *
+ * Method under test:
+ * {@link RestClientRegistrationClient#register(String, Application)}
+ */
+ @Test
+ @DisplayName("Test register(String, Application); given HashMap() 'id' is '42'; then return '42'")
+ @Tag("MaintainedByDiffblue")
+ void testRegister_givenHashMapIdIs42_thenReturn42() {
+ // Arrange
+ HashMap stringObjectMap = new HashMap<>();
+ stringObjectMap.put("id", "42");
+ ResponseSpec responseSpec = mock(ResponseSpec.class);
+ when(responseSpec.body(Mockito.>>any()))
+ .thenReturn(stringObjectMap);
+ RequestBodySpec requestBodySpec = mock(RequestBodySpec.class);
+ when(requestBodySpec.retrieve()).thenReturn(responseSpec);
+ RequestBodySpec requestBodySpec2 = mock(RequestBodySpec.class);
+ when(requestBodySpec2.body(Mockito.