Merge commit '98d5034' into service_label_and_annotation

Author: Vince Kraemer

integration-tests/README.md

@@ -26,26 +26,29 @@ Quick test use cases.
 6. verify domain life cycle(destroy and create) should not any impact on Operator managing the domain and web app load balancing and admin external service
 7. cluster scale up/down using Operator REST endpoint, webapp load balancing should adjust accordingly. (run.sh does scaling by editing the replicas in domain-custom-resource.yaml.)
 8. Operator life cycle(destroy and create) should not impact the running domain
+9. verify liveness probe by killing managed server 1 process 3 times to kick pod auto-restart
+10. shutdown the domain by changing domain serverStartPolicy to NEVER
 
 Full test use cases
 
-* keep the first domain and operator running
+* keep the first operator running
 * create another domain domain2 in default namespace and verify the domain by doing the checks 2 - 5 listed in quick test
-* destroy domain domain2
+* shutdown and delete domain domain2
 * create another domain domain3 with dynamic cluster using WDT in test1 namespace and verify the domain by doing the checks 2 - 5 listed in quick test
 * verify cluster scaling by doing scale up for domain3 using WLDF scaling 
-* destroy domain domain3
+* shutdown and delete domain domain3
 * create another operator operator2 which manages test2 namespace and verify domain1 is not affected
-* create another domain domain4 with Configured cluster using WDT in test2 namespace and verify the domain by doing the checks 2 - 5 listed in quick test
-* verify scaling for domain4 cluster from 2 to 3 servers and back to 2, plus verify no impact on domain1
-* cycle domain1 down and back up, plus verify no impact on domain4
-* create domain5 in the default namespace with serverStartPolicy="ADMIN_ONLY", and verify that only admin server is created. on Jenkins, this domain will also test NFS instead of HOSTPATH PV storage
-* create domain6 in the default namespace with pvReclaimPolicy="Recycle", and verify that the PV is deleted once the domain and PVC are deleted
-* test managed server 1 pod auto-restart in domain1
-* destroy domain1
-* test that create domain fails when its pv is already populated by a shutdown domain
-* create another domain domain7 with APACHE load balancer and access admin console via LB port. 
-* create another domain domain8 with mostly default values from sample domain inputs, mainly exposeAdminT3Channel and exposeAdminNodePort which are false by default and verify domain startup and cluster scaling using operator rest endpoint works. 
+* create another domain domain4 with dynamic cluster in default namespace and domain domain5 with Configured cluster using WDT in test2 namespace and verify the domain by doing the checks 2 - 5 listed in quick test
+* verify scaling for domain5 cluster from 2 to 3 servers and back to 2, plus verify no impact on domain4
+* cycle domain4 down and back up, plus verify no impact on domain5
+* shutdown and delete both domain4 and domain5 
+* create domain6 in the default namespace with serverStartPolicy="ADMIN_ONLY", and verify that only admin server is created. on Jenkins, this domain will also test NFS instead of HOSTPATH PV storage
+* shutdown and delete domain6
+* create domain7 in the default namespace with pvReclaimPolicy="Recycle", and verify that the PV is deleted once the domain and PVC are deleted
+* shutdown and delete domain7
+* create domain domain8 and test that create domain fails when its pv is already populated by a shutdown domain
+* create another domain domain9 with APACHE load balancer and access admin console via LB port. shutdown domain.
+* create another domain domain10 with mostly default values from sample domain inputs, mainly exposeAdminT3Channel and exposeAdminNodePort which are false by default and verify domain startup and cluster scaling using operator rest endpoint works. 
 
 
 # Directory Configuration and Structure

integration-tests/pom.xml

@@ -66,7 +66,12 @@
             <artifactId>snakeyaml</artifactId>
             <version>1.21</version>            
         </dependency>
-	</dependencies>
+        <dependency>
+            <groupId>io.kubernetes</groupId>
+            <artifactId>client-java</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 	<profiles>

integration-tests/src/test/java/oracle/kubernetes/operator/ITOperator.java

@@ -28,6 +28,8 @@ public class ITOperator extends BaseTest {
   // property file used to customize operator properties for operator inputs yaml
   private static String op1YamlFile = "operator1.yaml";
   private static String op2YamlFile = "operator2.yaml";
+  private static final String opForDelYamlFile1 = "operator_del1.yaml";
+  private static final String opForDelYamlFile2 = "operator_del2.yaml";
 
   // property file used to customize domain properties for domain inputs yaml
   private static String domain1YamlFile = "domain1.yaml";
@@ -38,12 +40,33 @@ public class ITOperator extends BaseTest {
   private static String domain6YamlFile = "domain6.yaml";
   private static String domain7YamlFile = "domain7.yaml";
   private static String domain8YamlFile = "domain8.yaml";
+  private static final String domain1ForDelValueYamlFile = "domain_del_1.yaml";
+  private static final String domain2ForDelValueYamlFile = "domain_del_2.yaml";
+  private static final String domain3ForDelValueYamlFile = "domain_del_3.yaml";
+  private static String domain9YamlFile = "domain9.yaml";
+  private static String domain10YamlFile = "domain10.yaml";
 
   // property file used to configure constants for integration tests
   private static String appPropsFile = "OperatorIT.properties";
 
   private static Operator operator1, operator2;
-  private static Domain domain1;
+
+  private static Operator operatorForDel1;
+  private static Operator operatorForDel2;
+
+  private static boolean QUICKTEST;
+  private static boolean SMOKETEST;
+
+  // Set QUICKTEST env var to true to run a small subset of tests.
+  // Set SMOKETEST env var to true to run an even smaller subset
+  // of tests, plus leave domain1 up and running when the test completes.
+  static {
+    QUICKTEST =
+        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true");
+    SMOKETEST =
+        System.getenv("SMOKETEST") != null && System.getenv("SMOKETEST").equalsIgnoreCase("true");
+    if (SMOKETEST) QUICKTEST = true;
+  }
 
   /**
    * This method gets called only once before any of the test methods are executed. It does the
@@ -93,17 +116,16 @@ public void test1CreateFirstOperatorAndDomain() throws Exception {
 
     logTestBegin("test1CreateFirstOperatorAndDomain");
     testCreateOperatorManagingDefaultAndTest1NS();
-    domain1 = testAllUseCasesForADomain(operator1, domain1YamlFile);
-    domain1.testWlsLivenessProbe();
-    domain1.destroy();
+    Domain domain1 = testAllUseCasesForADomain(operator1, domain1YamlFile);
+    if (!SMOKETEST) domain1.testWlsLivenessProbe();
+    if (!SMOKETEST) domain1.shutdownUsingServerStartPolicy();
 
     logger.info("SUCCESS - test1CreateFirstOperatorAndDomain");
   }
 
   @Test
   public void test2CreateAnotherDomainInDefaultNS() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test2CreateAnotherDomainInDefaultNS");
     logger.info("Creating Domain domain2 & verifing the domain creation");
@@ -120,8 +142,7 @@ public void test2CreateAnotherDomainInDefaultNS() throws Exception {
 
   @Test
   public void test3CreateDomainInTest1NS() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test3CreateDomainInTest1NS");
     logger.info("Creating Domain domain3 & verifing the domain creation");
@@ -137,8 +158,7 @@ public void test3CreateDomainInTest1NS() throws Exception {
 
   @Test
   public void test4CreateAnotherOperatorManagingTest2NS() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test4CreateAnotherOperatorManagingTest2NS");
     logger.info("Creating Operator & waiting for the script to complete execution");
@@ -149,8 +169,7 @@ public void test4CreateAnotherOperatorManagingTest2NS() throws Exception {
 
   @Test
   public void test5CreateConfiguredDomainInTest2NS() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test5CreateConfiguredDomainInTest2NS");
     logger.info("Creating Domain domain4 & verifing the domain creation");
@@ -159,124 +178,159 @@ public void test5CreateConfiguredDomainInTest2NS() throws Exception {
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
-    if (domain1 == null) {
-      domain1 = TestUtils.createDomain(domain1YamlFile);
-    } else {
-      domain1.create();
-    }
+    Domain domain4 = TestUtils.createDomain(domain4YamlFile);
+
     logger.info("Checking if operator2 is running, if not creating");
     if (operator2 == null) {
       operator2 = TestUtils.createOperator(op2YamlFile);
     }
-    // create domain4
-    Domain domain4 = testDomainCreation(domain4YamlFile);
+    // create domain5 with configured cluster
+    Domain domain5 = testDomainCreation(domain5YamlFile);
 
-    logger.info("Verify the only remaining running domain domain1 is unaffected");
-    domain1.verifyDomainCreated();
+    logger.info("Verify the only remaining running domain domain4 is unaffected");
+    domain4.verifyDomainCreated();
 
-    testClusterScaling(operator2, domain4);
+    testClusterScaling(operator2, domain5);
 
-    logger.info("Verify the only remaining running domain domain1 is unaffected");
-    domain1.verifyDomainCreated();
+    logger.info("Verify the only remaining running domain domain4 is unaffected");
+    domain4.verifyDomainCreated();
 
-    logger.info("Destroy and create domain1 and verify no impact on domain4");
-    domain1.destroy();
-    domain1.create();
+    logger.info("Destroy and create domain4 and verify no impact on domain5");
+    domain4.destroy();
+    domain4.create();
 
-    logger.info("Verify no impact on domain4");
-    domain4.verifyDomainCreated();
+    logger.info("Verify no impact on domain5");
+    domain5.verifyDomainCreated();
+    domain5.destroy();
     domain4.destroy();
-    domain1.destroy();
     logger.info("SUCCESS - test5CreateConfiguredDomainInTest2NS");
   }
 
   @Test
   public void test6CreateDomainWithStartPolicyAdminOnly() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test6CreateDomainWithStartPolicyAdminOnly");
     logger.info("Checking if operator1 is running, if not creating");
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
-    logger.info("Creating Domain domain5 & verifing the domain creation");
-    // create domain5
-    Domain domain5 = TestUtils.createDomain(domain5YamlFile);
-    domain5.destroy();
+    logger.info("Creating Domain domain6 & verifing the domain creation");
+    // create domain6
+    Domain domain6 = TestUtils.createDomain(domain6YamlFile);
+    domain6.destroy();
     logger.info("SUCCESS - test6CreateDomainWithStartPolicyAdminOnly");
   }
 
   @Test
   public void test7CreateDomainPVReclaimPolicyRecycle() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
 
     logTestBegin("test7CreateDomainPVReclaimPolicyRecycle");
     logger.info("Checking if operator1 is running, if not creating");
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
-    logger.info("Creating Domain domain6 & verifing the domain creation");
-    // create domain6
-    Domain domain6 = TestUtils.createDomain(domain6YamlFile);
-    domain6.shutdown();
-    domain6.deletePVCAndCheckPVReleased();
+    logger.info("Creating Domain domain7 & verifing the domain creation");
+    // create domain7
+    Domain domain7 = TestUtils.createDomain(domain7YamlFile);
+    domain7.shutdown();
+    domain7.deletePVCAndCheckPVReleased();
     logger.info("SUCCESS - test7CreateDomainPVReclaimPolicyRecycle");
   }
 
   @Test
-  public void test9CreateDomainOnExistingDir() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+  public void test8CreateDomainOnExistingDir() throws Exception {
+    Assume.assumeFalse(QUICKTEST);
 
-    logTestBegin("test9CreateDomainOnExistingDir");
+    logTestBegin("test8CreateDomainOnExistingDir");
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
-    if (domain1 == null) {
-      domain1 = TestUtils.createDomain(domain1YamlFile);
-      // create domain on existing dir
-      domain1.destroy();
-    }
-    logger.info("domain1 " + domain1);
-    domain1.createDomainOnExistingDirectory();
-    logger.info("SUCCESS - test9CreateDomainOnExistingDir");
+
+    Domain domain8 = TestUtils.createDomain(domain8YamlFile);
+    // create domain on existing dir
+    domain8.destroy();
+
+    domain8.createDomainOnExistingDirectory();
+    logger.info("SUCCESS - test8CreateDomainOnExistingDir");
   }
 
   // @Test
   public void testACreateDomainApacheLB() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
+
     logTestBegin("testACreateDomainApacheLB");
-    logger.info("Creating Domain domain7 & verifing the domain creation");
+    logger.info("Creating Domain domain9 & verifing the domain creation");
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
 
     // create domain7
-    Domain domain7 = TestUtils.createDomain(domain7YamlFile);
-    domain7.verifyAdminConsoleViaLB();
-    domain7.destroy();
+    Domain domain9 = TestUtils.createDomain(domain9YamlFile);
+    domain9.verifyAdminConsoleViaLB();
+    domain9.destroy();
     logger.info("SUCCESS - testACreateDomainApacheLB");
   }
 
   @Test
   public void testBCreateDomainWithDefaultValuesInSampleInputs() throws Exception {
-    Assume.assumeFalse(
-        System.getenv("QUICKTEST") != null && System.getenv("QUICKTEST").equalsIgnoreCase("true"));
+    Assume.assumeFalse(QUICKTEST);
+
     logTestBegin("testBCreateDomainWithDefaultValuesInSampleInputs");
-    logger.info("Creating Domain domain8 & verifing the domain creation");
+    logger.info("Creating Domain domain10 & verifing the domain creation");
     if (operator1 == null) {
       operator1 = TestUtils.createOperator(op1YamlFile);
     }
 
-    // create domain8
-    Domain domain8 = testAllUseCasesForADomain(operator1, domain8YamlFile);
-    domain8.destroy();
+    // create domain10
+    Domain domain10 = testAllUseCasesForADomain(operator1, domain10YamlFile);
+    domain10.destroy();
     logger.info("SUCCESS - testBCreateDomainWithDefaultValuesInSampleInputs");
   }
 
+  @Test
+  public void testDeleteOneDomain() throws Exception {
+    Assume.assumeFalse(QUICKTEST);
+    logTestBegin("Deleting one domain.");
+
+    if (operatorForDel1 == null) {
+      logger.info("About to create operator");
+      operatorForDel1 = TestUtils.createOperator(opForDelYamlFile1);
+    }
+    final Domain domain = TestUtils.createDomain(domain1ForDelValueYamlFile);
+    TestUtils.verifyBeforeDeletion(domain);
+
+    logger.info("About to delete domain: " + domain.getDomainUid());
+    TestUtils.deleteWeblogicDomainResources(domain.getDomainUid());
+
+    TestUtils.verifyAfterDeletion(domain);
+  }
+
+  @Test
+  public void testDeleteTwoDomains() throws Exception {
+    Assume.assumeFalse(QUICKTEST);
+    logTestBegin("Deleting two domains.");
+
+    if (operatorForDel2 == null) {
+      logger.info("About to create operator");
+      operatorForDel2 = TestUtils.createOperator(opForDelYamlFile2);
+    }
+    final Domain domainDel1 = TestUtils.createDomain(domain2ForDelValueYamlFile);
+    final Domain domainDel2 = TestUtils.createDomain(domain3ForDelValueYamlFile);
+
+    TestUtils.verifyBeforeDeletion(domainDel1);
+    TestUtils.verifyBeforeDeletion(domainDel2);
+
+    final String domainUidsToBeDeleted =
+        domainDel1.getDomainUid() + "," + domainDel2.getDomainUid();
+    logger.info("About to delete domains: " + domainUidsToBeDeleted);
+    TestUtils.deleteWeblogicDomainResources(domainUidsToBeDeleted);
+
+    TestUtils.verifyAfterDeletion(domainDel1);
+    TestUtils.verifyAfterDeletion(domainDel2);
+  }
+
   private void testCreateOperatorManagingDefaultAndTest1NS() throws Exception {
     logger.info("Creating Operator & waiting for the script to complete execution");
     // create operator1
@@ -288,9 +342,11 @@ private Domain testAllUseCasesForADomain(Operator operator, String domainYamlFil
     logger.info("Creating Domain & verifing the domain creation");
     // create domain1
     Domain domain = testDomainCreation(domainYamlFile);
-    testClusterScaling(operator, domain);
-    testDomainLifecyle(operator, domain);
-    testOperatorLifecycle(operator, domain);
+    if (!SMOKETEST) {
+      testClusterScaling(operator, domain);
+      testDomainLifecyle(operator, domain);
+      testOperatorLifecycle(operator, domain);
+    }
     return domain;
   }