Backport retry DB and RCU creation

Author: rjeberhard

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

@@ -14,137 +14,163 @@
 import oracle.kubernetes.operator.utils.TestUtils;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.MethodOrderer.Alphanumeric;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestMethodOrder;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 @TestMethodOrder(Alphanumeric.class)
 
 public class ItJrfPvWlst extends BaseTest {
  private static String rcuSchemaPrefix = "jrfdomain";
- private static Operator operator1;
+ private static Operator operator;
  private static String domainNS;
  private static String domainUid = "";
  private static String restartTmpDir = "";
  private static boolean testCompletedSuccessfully;
  private static String testClassName;
  private static StringBuffer namespaceList;
+ private static int dbPort;
+ private static String dbrcuNamespace;
+ private static String dbUrl;
+ private static JrfDomain jrfdomain;
 
  /**
- * This method gets called only once before any of the test methods are executed. It does the
- * initialization of the integration test properties defined in OperatorIT.properties and setting
- * the resultRoot, pvRoot and projectRoot attributes. It also creates Oracle DB pod which used for
- * RCU.
- *
- * @throws Exception - if an error occurs when load property file or create DB pod
- */
+ * This method gets called only once before any of the test methods are executed. It does the
+ * initialization of the integration test properties defined in OperatorIT.properties and sets
+ * the resultRoot, pvRoot and projectRoot attributes.
+ */
  @BeforeAll
- public static void staticPrepare() throws Exception {
+ public static void staticPrepare() {
  namespaceList = new StringBuffer();
  testClassName = new Object() {
  }.getClass().getEnclosingClass().getSimpleName();
- // initialize test properties 
- initialize(APP_PROPS_FILE, testClassName); 
+
+ LoggerHelper.getLocal().log(Level.INFO, "setting up properties, directories for: {0}",
+ testClassName);
+ assertDoesNotThrow(() -> initialize(APP_PROPS_FILE, testClassName),
+ "Failed: initial setup");
  }
 
  /**
- * Prepare test.
- * @throws Exception on failure
+ * This method gets called before every test. It creates the result/pv root directories
+ * for the test. It also creates RCU schema, operator.
  */
  @BeforeEach
- public void prepare() throws Exception {
- if (QUICKTEST) {
- createResultAndPvDirs(testClassName);
- 
- TestUtils.execOrAbortProcess(
- "cp -rf " 
- + BaseTest.getProjectRoot() 
- + "/kubernetes/samples/scripts " 
- + getResultDir(),
- true);
- //delete leftover pods caused by test being aborted
- DbUtils.deleteRcuPod(getResultDir());
- DbUtils.stopOracleDB(getResultDir());
- 
- DbUtils.startOracleDB(getResultDir());
- DbUtils.createRcuSchema(getResultDir(),rcuSchemaPrefix);
- 
- // create operator1
- if (operator1 == null) {
- Map<String, Object> operatorMap = createOperatorMap(getNewSuffixCount(),
- true, testClassName);
- operator1 = TestUtils.createOperator(operatorMap, Operator.RestCertType.SELF_SIGNED);
- Assertions.assertNotNull(operator1);
- domainNS = ((ArrayList<String>) operatorMap.get("domainNamespaces")).get(0);
- namespaceList.append((String)operatorMap.get("namespace"));
- namespaceList.append(" ").append(domainNS);
- }
- } 
+ public void prepare() {
+ LoggerHelper.getLocal().log(Level.INFO, "Creating result/pv root directories");
+ assertDoesNotThrow(() -> createResultAndPvDirs(testClassName),
+ "Failed: createResultAndPvDirs");
+
+ LoggerHelper.getLocal().log(Level.INFO, "Copying sample dir to the result dir");
+ assertDoesNotThrow(() -> TestUtils.execOrAbortProcess(
+ "cp -rf "
+ + BaseTest.getProjectRoot()
+ + "/kubernetes/samples/scripts "
+ + getResultDir(),
+ true),
+ "Failed: Copy sample dir to the result dir");
+
+ //start DB and create RCU
+ dbrcuNamespace = "dbrcu" + String.valueOf(getNewSuffixCount());
+ dbPort = 30011 + getNewSuffixCount();
+ dbUrl = "oracle-db." + dbrcuNamespace + ".svc.cluster.local:1521/devpdb.k8s";
+ assertDoesNotThrow(() -> DbUtils.setupRcuDatabase(getResultDir(), dbPort, dbUrl,
+ rcuSchemaPrefix, dbrcuNamespace));
+
+ // create operator
+ if (operator == null) {
+ Map<String, Object> operatorMap = createOperatorMap(getNewSuffixCount(),
+ true, testClassName);
+ operator = assertDoesNotThrow(() -> TestUtils.createOperator(operatorMap,
+ Operator.RestCertType.SELF_SIGNED));
+ assertNotNull(operator);
+ LoggerHelper.getLocal().log(Level.INFO, "Operator is created for {0}", testClassName);
+
+ domainNS = ((ArrayList<String>) operatorMap.get("domainNamespaces")).get(0);
+ namespaceList.append((String)operatorMap.get("namespace"));
+ namespaceList.append(" ").append(domainNS);
+ }
  }
- 
+
+ /**
+ * This method will run once after every test method is finished. It delete both RCU and DB pods.
+ */
  @AfterEach
- public void unPrepare() throws Exception {
- DbUtils.deleteRcuPod(getResultDir());
- DbUtils.stopOracleDB(getResultDir());
+ public void unPrepare() {
+ LoggerHelper.getLocal().log(Level.INFO, "Is going to drop RCU schema and stop DB for {0}", testClassName);
+ assertDoesNotThrow(() -> DbUtils.deleteRcuPod(getResultDir()),
+ "Failed: drop RCU schema");
+ assertDoesNotThrow(() -> DbUtils.deleteDbPod(getResultDir()),
+ "Failed: stop DB");
  }
- 
+
  /**
- * This method will run once after all test methods are finished. It Releases k8s cluster lease,
- * archives result, pv directories.
- *
- * @throws Exception - if any error occurs
- */
+ * Releases k8s cluster lease, archives result, pv directories.
+ */
  @AfterAll
- public static void staticUnPrepare() throws Exception {
- tearDown(new Object() {
- }.getClass().getEnclosingClass().getSimpleName(), namespaceList.toString());
-
- LoggerHelper.getLocal().log(Level.INFO,"SUCCESS");
+ public static void staticUnPrepare() {
+ assertDoesNotThrow(() -> tearDown(new Object() {
+ }.getClass().getEnclosingClass().getSimpleName(), namespaceList.toString()),
+ "tearDown failed");
  }
- 
+
+ /**
+ * Create and deploy a JRF domain. Verify the domain is created successfully.
+ */
  @Test
- public void testJrfDomainOnPvUsingWlst() throws Exception {
+ public void testJrfDomainOnPvUsingWlst() {
  if (QUICKTEST) {
  String testMethodName = new Object() {
  }.getClass().getEnclosingMethod().getName();
- logTestBegin(testMethodName);
  LoggerHelper.getLocal().log(Level.INFO,
- "Creating Operator & waiting for the script to complete execution");
- 
- JrfDomain jrfdomain = null;
+ "+++++++++++++++++++++++++++++++++---------------------------------+");
+ LoggerHelper.getLocal().log(Level.INFO, "BEGIN " + testMethodName);
+
  boolean testCompletedSuccessfully = false;
 
  try {
  // create JRF domain
  Map<String, Object> domainMap = createDomainMap(getNewSuffixCount(), testClassName);
  domainMap.put("namespace", domainNS);
  domainMap.put("initialManagedServerReplicas", new Integer("2"));
- domainMap.put("image", "container-registry.oracle.com/middleware/fmw-infrastructure:12.2.1.4");
  domainMap.put("clusterName", "infra-cluster");
  domainMap.put("managedServerNameBase", "infraserver");
+ domainMap.put("domainHomeSourceType", "PersistentVolume");
  domainMap.put("rcuSchemaPrefix", "jrfdomain");
- domainMap.put("rcuDatabaseURL", "oracle-db.default.svc.cluster.local:1521/devpdb.k8s");
+ LoggerHelper.getLocal().log(Level.INFO, "DEBUG " + testClassName + "domain: dbUrl: "
+ + dbUrl);
+ domainMap.put("rcuDatabaseURL", dbUrl);
  domainUid = (String) domainMap.get("domainUID");
  LoggerHelper.getLocal().log(Level.INFO,
  "Creating and verifying the domain creation with domainUid: " + domainUid);
 
- jrfdomain = new JrfDomain(domainMap);
- jrfdomain.verifyDomainCreated(80);
- 
+ jrfdomain = assertDoesNotThrow(() -> new JrfDomain(domainMap),
+ "Failed: JRF domain creation");
+ LoggerHelper.getLocal().log(Level.INFO, "JRF domain is created for {0}",
+ testClassName);
+ assertDoesNotThrow(() -> jrfdomain.verifyDomainCreated(),
+ "Failed: domain verification");
+ LoggerHelper.getLocal().log(Level.INFO, "JRF domain verification succeeded for {0}",
+ testClassName);
+
  // basic test cases
- testBasicUseCases(jrfdomain, false);
+ assertDoesNotThrow(() -> testBasicUseCases(jrfdomain, false));
+ LoggerHelper.getLocal().log(Level.INFO, "JRF domain BasicUseCases succeeded for {0}",
+ testClassName);
 
  testCompletedSuccessfully = true;
  } finally {
  if (jrfdomain != null && (JENKINS || testCompletedSuccessfully)) {
- jrfdomain.shutdownUsingServerStartPolicy();
+ assertDoesNotThrow(() -> jrfdomain.shutdownUsingServerStartPolicy());
  }
  }
 
  LoggerHelper.getLocal().log(Level.INFO, "SUCCESS - " + testMethodName);
  }
  }
-}
+}