Added tests, which cover replacing existing service, for ExternalService. WIP (due to broken Cluster#fillInFrom) for adding more the aforementioned tests for ClusterService,

Author: chunshi-ora

model/src/main/java/oracle/kubernetes/weblogic/domain/v2/DomainV2Configurator.java

@@ -451,13 +451,13 @@ public ClusterConfigurator withPodAnnotation(String name, String value) {
 
     @Override
     public ClusterConfigurator withServiceLabel(String name, String value) {
-      cluster.addServiceLabel(name, value);
+      cluster.addClusterLabel(name, value);
       return this;
     }
 
     @Override
     public ClusterConfigurator withServiceAnnotation(String name, String value) {
-      cluster.addServiceAnnotation(name, value);
+      cluster.addClusterAnnotation(name, value);
       return this;
     }
 

operator/src/test/java/oracle/kubernetes/operator/helpers/ServiceHelperTest.java

@@ -56,9 +56,11 @@
 import oracle.kubernetes.operator.wlsconfig.WlsDomainConfig;
 import oracle.kubernetes.operator.work.Step;
 import oracle.kubernetes.operator.work.TerminalStep;
+import oracle.kubernetes.weblogic.domain.AdminServerConfigurator;
+import oracle.kubernetes.weblogic.domain.DomainConfigurator;
+import oracle.kubernetes.weblogic.domain.DomainConfiguratorFactory;
 import oracle.kubernetes.weblogic.domain.v2.Domain;
 import oracle.kubernetes.weblogic.domain.v2.DomainSpec;
-import oracle.kubernetes.weblogic.domain.v2.ManagedServer;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -69,11 +71,11 @@ public class ServiceHelperTest {
   private static final String NS = "namespace";
   private static final String TEST_CLUSTER = "cluster-1";
   private static final int TEST_NODE_PORT = 7002;
+  private static final int BAD_NODE_PORT = 9900;
   private static final int TEST_PORT = 7000;
   private static final int BAD_PORT = 9999;
   private static final String DOMAIN_NAME = "domain1";
   private static final String TEST_SERVER_NAME = "server1";
-  private static final String TEST_ADMIN_NAME = "admin";
   private static final String SERVICE_NAME = "service1";
   private static final String UID = "uid1";
   private static final String BAD_VERSION = "bad-version";
@@ -98,24 +100,26 @@ public class ServiceHelperTest {
   private final TerminalStep terminalStep = new TerminalStep();
   private RetryStrategyStub retryStrategy = createStrictStub(RetryStrategyStub.class);
   private List<LogRecord> logRecords = new ArrayList<>();
+  private WlsDomainConfig domainConfig;
 
   public ServiceHelperTest() {}
 
   @Before
   public void setUp() throws Exception {
+    configureAdminServer().configureAdminService().withChannel("default", TEST_NODE_PORT);
     mementos.add(
         TestUtils.silenceOperatorLogger()
             .collectLogMessages(logRecords, MESSAGE_KEYS)
             .withLogLevel(Level.FINE));
     mementos.add(testSupport.installRequestStepFactory());
 
     WlsDomainConfigSupport configSupport = new WlsDomainConfigSupport(DOMAIN_NAME);
-    configSupport.addWlsServer(ADMIN_SERVER);
+    configSupport.addWlsServer(ADMIN_SERVER, TEST_PORT);
     configSupport.addWlsServer(TEST_SERVER_NAME, TEST_PORT);
     configSupport.addWlsCluster(TEST_CLUSTER, TEST_SERVER_NAME);
     configSupport.setAdminServerName(ADMIN_SERVER);
 
-    WlsDomainConfig domainConfig = configSupport.createDomainConfig();
+    domainConfig = configSupport.createDomainConfig();
     testSupport
         .addToPacket(CLUSTER_NAME, TEST_CLUSTER)
         .addToPacket(SERVER_NAME, TEST_SERVER_NAME)
@@ -141,6 +145,14 @@ private DomainSpec createDomainSpec() {
     return new DomainSpec().withDomainUID(UID);
   }
 
+  private AdminServerConfigurator configureAdminServer() {
+    return configureDomain().configureAdminServer();
+  }
+
+  private DomainConfigurator configureDomain() {
+    return DomainConfiguratorFactory.forDomain(domainPresenceInfo.getDomain());
+  }
+
   // ------ service deletion --------
 
   @Test
@@ -266,38 +278,25 @@ public void onClusterStepRunWithMatchingServiceWithoutSpecType_addToDomainPresen
 
   @Test
   public void onClusterStepRunWithServiceWithBadVersion_replaceIt() {
-    initializeClusterServiceFromRecord(createClusterServiceWithBadVersion());
-    expectDeleteServiceSuccessful(getClusterServiceName());
-    expectSuccessfulCreateClusterService();
-
-    testSupport.runSteps(ServiceHelper.createForClusterStep(terminalStep));
-
-    assertThat(domainPresenceInfo.getClusters(), hasEntry(TEST_CLUSTER, createClusterService()));
-    assertThat(logRecords, containsInfo(CLUSTER_SERVICE_REPLACED));
+    verifyClusterServiceReplaced(this::withBadVersion);
   }
 
   @Test
   public void onClusterStepRunWithServiceWithBadSpecType_replaceIt() {
-    initializeClusterServiceFromRecord(createClusterServiceWithBadSpecType());
-    expectDeleteServiceSuccessful(getClusterServiceName());
-    expectSuccessfulCreateClusterService();
-
-    testSupport.runSteps(ServiceHelper.createForClusterStep(terminalStep));
-
-    assertThat(domainPresenceInfo.getClusters(), hasEntry(TEST_CLUSTER, createClusterService()));
-    assertThat(logRecords, containsInfo(CLUSTER_SERVICE_REPLACED));
+    verifyClusterServiceReplaced(this::withBadSpecType);
   }
 
   @Test
   public void onClusterStepRunWithServiceWithBadPort_replaceIt() {
-    initializeClusterServiceFromRecord(createClusterServiceWithBadPort());
-    expectDeleteServiceSuccessful(getClusterServiceName());
-    expectSuccessfulCreateClusterService();
-
-    testSupport.runSteps(ServiceHelper.createForClusterStep(terminalStep));
+    verifyClusterServiceReplaced(this::withBadPort);
+  }
 
-    assertThat(domainPresenceInfo.getClusters(), hasEntry(TEST_CLUSTER, createClusterService()));
-    assertThat(logRecords, containsInfo(CLUSTER_SERVICE_REPLACED));
+  // TODO: oracle.kubernetes.weblogic.domain.v2.Cluster.getConfiguration is broken. Doesn't fill in
+  // Cluster#clusterService.
+  // @Test
+  public void onClusterStepRunWithServiceWithLabelAdded_replaceIt() {
+    configureClusterWithLabel("anyLabel", "anyValue");
+    verifyClusterServiceReplaced(createClusterService(), withLabel(createClusterService()));
   }
 
   @Test
@@ -394,12 +393,6 @@ private V1Service createClusterServiceWithBadVersion() {
         .metadata(new V1ObjectMeta().putLabelsItem(RESOURCE_VERSION_LABEL, BAD_VERSION));
   }
 
-  private V1Service createClusterServiceWithBadSpecType() {
-    return new V1Service()
-        .spec(new V1ServiceSpec().type("BadType"))
-        .metadata(new V1ObjectMeta().putLabelsItem(RESOURCE_VERSION_LABEL, DEFAULT_DOMAIN_VERSION));
-  }
-
   private V1Service createClusterServiceWithBadPort() {
     return new V1Service()
         .spec(createSpecWithBadPort())
@@ -479,14 +472,14 @@ public void onServerStepRunWithServiceWithBadVersion_replaceIt() {
 
   @Test
   public void onServerStepRunWithServiceWithLabelAdded_replaceIt() {
-    createManagedServerWithLabel("anyLabel", "anyValue");
+    configureManagedServerWithLabel("anyLabel", "anyValue");
     verifyServerServiceReplaced(createServerService(), withLabel(createServerService()));
   }
 
   @Test
   public void onServerStepRunWithServiceWithLabelValueChanged_replaceIt() {
     final String newLabelValue = "newValue";
-    createManagedServerWithLabel("anyLabel", newLabelValue);
+    configureManagedServerWithLabel("anyLabel", newLabelValue);
     verifyServerServiceReplaced(
         withLabel(createServerService()), withLabel(createServerService(), newLabelValue));
   }
@@ -498,14 +491,14 @@ public void onServerStepRunWithServiceWithLabelRemoved_replaceIt() {
 
   @Test
   public void onServerStepRunWithServiceWithAnnotationAdded_replaceIt() {
-    createManagedServerWithAnnotation("anyAnnotation", "anyValue");
+    configureManagedServerWithAnnotation("anyAnnotation", "anyValue");
     verifyServerServiceReplaced(createServerService(), withAnnotation(createServerService()));
   }
 
   @Test
   public void onServerStepRunWithServiceWithAnnotationValueChanged_replaceIt() {
     final String newAnnotationValue = "newValue";
-    createManagedServerWithAnnotation("anyAnnotation", newAnnotationValue);
+    configureManagedServerWithAnnotation("anyAnnotation", newAnnotationValue);
     verifyServerServiceReplaced(
         withAnnotation(createServerService()),
         withAnnotation(createServerService(), newAnnotationValue));
@@ -517,8 +510,57 @@ public void onServerStepRunWithServiceWithAnnotationRemoved_replaceIt() {
   }
 
   @Test
-  public void onExternalStepRunWithServiceWithBadVersion_replaceIt() {
-    verifyAdminServiceReplaced(this::withBadVersion);
+  public void onExternalServiceStepRunWithServiceWithBadVersion_replaceIt() {
+    verifyExternalServiceReplaced(this::withBadVersion);
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithBadPort_replaceIt() {
+    verifyExternalServiceReplaced(this::withBadPort);
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithBadNodePort_replaceIt() {
+    verifyExternalServiceReplaced(this::withBadNodePort);
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithLabelAdded_replaceIt() {
+    configureAdminServerWithLabel("anyLabel", "anyValue");
+    verifyExternalServiceReplaced(createAdminService(), withLabel(createAdminService()));
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithLabelValueChanged_replaceIt() {
+    final String newLabelValue = "newValue";
+    configureAdminServerWithLabel("anyLabel", newLabelValue);
+    verifyExternalServiceReplaced(
+        withLabel(createAdminService()), withLabel(createAdminService(), newLabelValue));
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithLabelRemoved_replaceIt() {
+    verifyExternalServiceReplaced(this::withLabel);
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithAnnotationAdded_replaceIt() {
+    configureAdminServerWithAnnotation("anyAnnotation", "anyValue");
+    verifyExternalServiceReplaced(createAdminService(), withAnnotation(createAdminService()));
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithAnnotationValueChanged_replaceIt() {
+    final String newAnnotationValue = "newValue";
+    configureAdminServerWithAnnotation("anyAnnotation", newAnnotationValue);
+    verifyExternalServiceReplaced(
+        withAnnotation(createAdminService()),
+        withAnnotation(createAdminService(), newAnnotationValue));
+  }
+
+  @Test
+  public void onExternalServiceStepRunWithServiceWithAnnotationRemoved_replaceIt() {
+    verifyExternalServiceReplaced(this::withAnnotation);
   }
 
   private void verifyServerServiceReplaced(V1Service oldService, V1Service newService) {
@@ -531,15 +573,17 @@ private void verifyServerServiceReplaced(V1Service oldService, V1Service newServ
     assertThat(logRecords, containsInfo(MANAGED_SERVICE_REPLACED));
   }
 
-  private void verifyAdminServiceReplaced(ServiceMutator mutator) {
-    verifyAdminServiceReplaced(mutator.change(createAdminService()), createAdminService());
+  private void verifyExternalServiceReplaced(ServiceMutator mutator) {
+    verifyExternalServiceReplaced(mutator.change(createAdminService()), createAdminService());
   }
 
-  private void verifyAdminServiceReplaced(V1Service oldService, V1Service newService) {
+  private void verifyExternalServiceReplaced(V1Service oldService, V1Service newService) {
     initializeAdminServiceFromRecord(oldService);
     expectDeleteServiceSuccessful(getAdminServiceName());
     expectSuccessfulCreateService(newService);
 
+    testSupport.addToPacket(SERVER_SCAN, domainConfig.getServerConfig(ADMIN_SERVER));
+    testSupport.addToPacket(SERVER_NAME, ADMIN_SERVER);
     testSupport.runSteps(ServiceHelper.createForExternalServiceStep(terminalStep));
 
     assertThat(logRecords, containsInfo(ADMIN_SERVICE_REPLACED));
@@ -549,6 +593,21 @@ private void verifyServerServiceReplaced(ServiceMutator mutator) {
     verifyServerServiceReplaced(mutator.change(createServerService()), createServerService());
   }
 
+  private void verifyClusterServiceReplaced(ServiceMutator mutator) {
+    verifyClusterServiceReplaced(mutator.change(createClusterService()), createClusterService());
+  }
+
+  private void verifyClusterServiceReplaced(V1Service oldService, V1Service newService) {
+    initializeClusterServiceFromRecord(oldService);
+    expectDeleteServiceSuccessful(getClusterServiceName());
+    expectCreateService(newService).returning(newService);
+
+    testSupport.runSteps(ServiceHelper.createForClusterStep(terminalStep));
+
+    assertThat(domainPresenceInfo.getClusters(), hasEntry(TEST_CLUSTER, newService));
+    assertThat(logRecords, containsInfo(CLUSTER_SERVICE_REPLACED));
+  }
+
   private V1ServiceSpec createServerServiceSpec() {
     return createUntypedServerServiceSpec(TEST_SERVER_NAME).type("ClusterIP").clusterIP("None");
   }
@@ -568,15 +627,15 @@ private void initializeServiceFromRecord(V1Service service) {
   }
 
   private void initializeAdminServiceFromRecord(V1Service service) {
-    domainPresenceInfo.getServers().put(TEST_ADMIN_NAME, createSko(service));
+    domainPresenceInfo.getServers().put(ADMIN_SERVER, createSko(service));
   }
 
   private String getServerServiceName() {
     return LegalNames.toServerServiceName(UID, TEST_SERVER_NAME);
   }
 
   private String getAdminServiceName() {
-    return LegalNames.toExternalServiceName(UID, TEST_ADMIN_NAME);
+    return LegalNames.toExternalServiceName(UID, ADMIN_SERVER);
   }
 
   private void expectSuccessfulCreateService(V1Service service) {
@@ -624,13 +683,12 @@ private V1Service createAdminService(V1ServiceSpec serviceSpec) {
                 .putLabelsItem(RESOURCE_VERSION_LABEL, VersionConstants.DOMAIN_V2)
                 .putLabelsItem(DOMAINUID_LABEL, UID)
                 .putLabelsItem(DOMAINNAME_LABEL, DOMAIN_NAME)
-                .putLabelsItem(SERVERNAME_LABEL, TEST_ADMIN_NAME)
+                .putLabelsItem(SERVERNAME_LABEL, ADMIN_SERVER)
                 .putLabelsItem(CREATEDBYOPERATOR_LABEL, "true"));
   }
 
   private V1ServiceSpec createAdminServiceSpec() {
-    final V1ServiceSpec serviceSpec =
-        createUntypedServerServiceSpec(TEST_ADMIN_NAME).type("NodePort");
+    final V1ServiceSpec serviceSpec = createUntypedServerServiceSpec(ADMIN_SERVER).type("NodePort");
 
     serviceSpec.getPorts().stream().findAny().ifPresent(port -> port.setNodePort(TEST_NODE_PORT));
 
@@ -646,6 +704,27 @@ private V1Service withBadVersion(V1Service service) {
     return service;
   }
 
+  private V1Service withBadSpecType(V1Service service) {
+    service.getSpec().type("BadType");
+    return service;
+  }
+
+  private V1Service withBadPort(V1Service service) {
+    List<V1ServicePort> ports = service.getSpec().getPorts();
+    assertThat(ports.size(), is(1));
+
+    ports.stream().findAny().get().setPort(BAD_PORT);
+    return service;
+  }
+
+  private V1Service withBadNodePort(V1Service service) {
+    List<V1ServicePort> ports = service.getSpec().getPorts();
+    assertThat(ports.size(), is(1));
+
+    ports.stream().findAny().get().setNodePort(BAD_NODE_PORT);
+    return service;
+  }
+
   private V1Service withLabel(V1Service service) {
     return withLabel(service, "anyValue");
   }
@@ -674,18 +753,24 @@ private V1Service withAnnotation(V1Service service, String value) {
     return service;
   }
 
-  private void createManagedServerWithLabel(String label, String value) {
-    final ManagedServer ms = new ManagedServer();
-    ms.setServerName(TEST_SERVER_NAME);
-    ms.getServiceLabels().put(label, value);
-    domainPresenceInfo.getDomain().getSpec().getManagedServers().add(ms);
+  private void configureClusterWithLabel(String label, String value) {
+    configureDomain().configureCluster(TEST_CLUSTER).withServiceLabel(label, value);
+  }
+
+  private void configureManagedServerWithLabel(String label, String value) {
+    configureDomain().configureServer(TEST_SERVER_NAME).withServiceLabel(label, value);
+  }
+
+  private void configureManagedServerWithAnnotation(String annotation, String value) {
+    configureDomain().configureServer(TEST_SERVER_NAME).withServiceAnnotation(annotation, value);
+  }
+
+  private void configureAdminServerWithLabel(String label, String value) {
+    configureDomain().configureAdminServer().withServiceLabel(label, value);
   }
 
-  private void createManagedServerWithAnnotation(String annotation, String value) {
-    final ManagedServer ms = new ManagedServer();
-    ms.setServerName(TEST_SERVER_NAME);
-    ms.getServiceAnnotations().put(annotation, value);
-    domainPresenceInfo.getDomain().getSpec().getManagedServers().add(ms);
+  private void configureAdminServerWithAnnotation(String annotation, String value) {
+    configureDomain().configureAdminServer().withServiceAnnotation(annotation, value);
   }
 
   private CallTestSupport.CannedResponse expectReadService(String serviceName) {