Improve the MySQL DB test storage feature.

mdmintz · mdmintz · commit 518594e9abd6 · 2018-04-12T15:54:21.000-04:00
diff --git a/seleniumbase/core/mysql.py b/seleniumbase/core/mysql.py
@@ -8,7 +8,7 @@
 
 class DatabaseManager():
     """
-    This class wraps database functions for easy use.
+    This class wraps MySQL database methods for easy use.
     It connects to the testcase database.
     """
 
@@ -40,7 +40,7 @@ def __init__(self, database_env='test', conf_creds=None):
 
     def fetchall_query_and_close(self, query, values):
         """
-        Executes a query, gets all the values and then closes up the connection
+        Executes a query, gets all the values, and closes the connection.
         """
         self.cursor.execute(query, values)
         retval = self.cursor.fetchall()
@@ -49,7 +49,7 @@ def fetchall_query_and_close(self, query, values):
 
     def fetchone_query_and_close(self, query, values):
         """
-        Executes a query, gets the first value, and closes up the connection
+        Executes a query, gets the first value, and closes the connection.
         """
         self.cursor.execute(query, values)
         retval = self.cursor.fetchone()
@@ -58,7 +58,7 @@ def fetchone_query_and_close(self, query, values):
 
     def execute_query_and_close(self, query, values):
         """
-        Executes a query and closes the connection
+        Executes a query and closes the connection.
         """
         retval = self.cursor.execute(query, values)
         self.__close_db()
diff --git a/seleniumbase/core/mysql_conf.py b/seleniumbase/core/mysql_conf.py
@@ -1,6 +1,5 @@
 """
-This file contains database credentials for the various databases
-that the tests need to access
+This file organizes connection details to the Testcase Database.
 """
 
 from seleniumbase.config import settings
diff --git a/seleniumbase/core/testcase_manager.py b/seleniumbase/core/testcase_manager.py
@@ -1,24 +1,17 @@
-"""
-Testcase database related methods
-"""
-
 from seleniumbase.core.mysql import DatabaseManager
 
 
 class TestcaseManager:
-    """
-    Helper for Testcase related DB stuff
-    """
 
     def __init__(self, database_env):
         self.database_env = database_env
 
     def insert_execution_data(self, execution_query_payload):
-        """ Inserts an execution into the database.
+        """ Inserts a test execution row into the database.
             Returns the execution guid. """
 
         query = """INSERT INTO execution
-                   (guid, executionStart, totalExecutionTime, username)
+                   (guid, execution_start, total_execution_time, username)
                    VALUES (%(guid)s,%(execution_start_time)s,
                            %(total_execution_time)s,%(username)s)"""
         DatabaseManager(self.database_env).execute_query_and_close(
@@ -27,70 +20,63 @@ def insert_execution_data(self, execution_query_payload):
         return execution_query_payload.guid
 
     def update_execution_data(self, execution_guid, execution_time):
-        """updates an existing execution in the database"""
-
+        """ Updates an existing test execution row in the database. """
         query = """UPDATE execution
-                   SET totalExecutionTime=%(execution_time)s
+                   SET total_execution_time=%(execution_time)s
                    WHERE guid=%(execution_guid)s """
         DatabaseManager(self.database_env).execute_query_and_close(
             query,
             {"execution_guid": execution_guid,
              "execution_time": execution_time})
 
     def insert_testcase_data(self, testcase_run_payload):
-        """inserts all data for the test case, returns the new row guid"""
-
-        query = """INSERT INTO testcaseRunData
-                   (guid, browser, state, execution_guid, env, start_time,
-                    testcaseAddress, runtime, retryCount, message, stackTrace)
+        """ Inserts all data for the test in the DB. Returns new row guid. """
+        query = """INSERT INTO test_run_data(
+                   guid, browser, state, execution_guid, env, start_time,
+                   test_address, runtime, retry_count, message, stack_trace)
                           VALUES (
                               %(guid)s,
                               %(browser)s,
                               %(state)s,
                               %(execution_guid)s,
                               %(env)s,
                               %(start_time)s,
-                              %(testcaseAddress)s,
+                              %(test_address)s,
                               %(runtime)s,
-                              %(retryCount)s,
+                              %(retry_count)s,
                               %(message)s,
-                              %(stackTrace)s) """
+                              %(stack_trace)s) """
         DatabaseManager(self.database_env).execute_query_and_close(
             query, testcase_run_payload.get_params())
 
     def update_testcase_data(self, testcase_payload):
-        """updates an existing testcase run in the database"""
-
-        query = """UPDATE testcaseRunData SET
-                          runtime=%(runtime)s,
-                          state=%(state)s,
-                          retryCount=%(retryCount)s,
-                          stackTrace=%(stackTrace)s,
-                          message=%(message)s
-                          WHERE guid=%(guid)s """
+        """ Updates an existing test run in the database. """
+        query = """UPDATE test_run_data SET
+                            runtime=%(runtime)s,
+                            state=%(state)s,
+                            retry_count=%(retry_count)s,
+                            stack_trace=%(stack_trace)s,
+                            message=%(message)s
+                            WHERE guid=%(guid)s """
         DatabaseManager(self.database_env).execute_query_and_close(
             query, testcase_payload.get_params())
 
     def update_testcase_log_url(self, testcase_payload):
-        """updates an existing testcase run's logging URL in the database"""
-
-        query = """UPDATE testcaseRunData
-                   SET logURL=%(logURL)s
+        query = """UPDATE test_run_data
+                   SET log_url=%(log_url)s
                    WHERE guid=%(guid)s """
         DatabaseManager(self.database_env).execute_query_and_close(
             query, testcase_payload.get_params())
 
 
 class ExecutionQueryPayload:
-    """ Helper class for containing the execution query data """
     def __init__(self):
         self.execution_start_time = None
         self.total_execution_time = -1
         self.username = "Default"
         self.guid = None
 
     def get_params(self):
-        """ Returns a params object for use with the pool """
         return {
             "execution_start_time": self.execution_start_time,
             "total_execution_time": self.total_execution_time,
@@ -100,10 +86,9 @@ def get_params(self):
 
 
 class TestcaseDataPayload:
-    """ Helper class for containing all the testcase query data """
     def __init__(self):
         self.guid = None
-        self.testcaseAddress = None
+        self.test_address = None
         self.browser = None
         self.state = None
         self.execution_guid = None
@@ -113,21 +98,20 @@ def __init__(self):
         self.retry_count = 0
         self.stack_trace = None
         self.message = None
-        self.logURL = None
+        self.log_url = None
 
     def get_params(self):
-        """ Returns a params object for use with the pool """
         return {
             "guid": self.guid,
-            "testcaseAddress": self.testcaseAddress,
+            "test_address": self.test_address,
             "browser": self.browser,
             "state": self.state,
             "execution_guid": self.execution_guid,
             "env": self.env,
             "start_time": self.start_time,
             "runtime": self.runtime,
-            "retryCount": self.retry_count,
-            "stackTrace": self.stack_trace,
+            "retry_count": self.retry_count,
+            "stack_trace": self.stack_trace,
             "message": self.message,
-            "logURL": self.logURL
+            "log_url": self.log_url
         }
diff --git a/seleniumbase/core/testcaserepository.sql b/seleniumbase/core/testcaserepository.sql
@@ -1,41 +1,41 @@
-# table delayedTestData
+# test_run_data table
 # -----------------------------------
-CREATE TABLE `delayedTestData` (
+CREATE TABLE `test_run_data` (
   `guid` varchar(64) NOT NULL DEFAULT '',
-  `testcaseAddress` varchar(255) NOT NULL DEFAULT '',
-  `insertedAt` bigint(20) NOT NULL,
-  `expectedResult` text,
-  `done` tinyint(1) DEFAULT '0',
-  `expiresAt` bigint(20) DEFAULT NULL,
-  PRIMARY KEY (`guid`),
-  UNIQUE KEY `uuid` (`guid`)
+  `test_address` varchar(255) DEFAULT NULL,
+  `env` varchar(64) DEFAULT NULL,
+  `start_time` varchar(64) DEFAULT NULL,
+  `execution_guid` varchar(64) DEFAULT NULL,
+  `runtime` int(11),
+  `state` varchar(64) DEFAULT NULL,
+  `browser` varchar(64) DEFAULT NULL,
+  `message` text,
+  `stack_trace` text,
+  `retry_count` int(11) DEFAULT '0',
+  `exception_map_guid` varchar(64) DEFAULT NULL,
+  `log_url` text,
+  PRIMARY KEY (`guid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-# table execution
+# execution table
 # -----------------------------------
 CREATE TABLE `execution` (
   `guid` varchar(64) NOT NULL DEFAULT '',
-  `totalExecutionTime` int(11),
+  `total_execution_time` int(11),
   `username` varchar(255) DEFAULT NULL,
-  `executionStart` bigint(20) DEFAULT '0',
+  `execution_start` bigint(20) DEFAULT '0',
   PRIMARY KEY (`guid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-# table testcaseRunData
+# delayed_test_data table
 # -----------------------------------
-CREATE TABLE `testcaseRunData` (
+CREATE TABLE `delayed_test_data` (
   `guid` varchar(64) NOT NULL DEFAULT '',
-  `testcaseAddress` varchar(255) DEFAULT NULL,
-  `env` varchar(64) DEFAULT NULL,
-  `start_time` varchar(64) DEFAULT NULL,
-  `execution_guid` varchar(64) DEFAULT NULL,
-  `runtime` int(11),
-  `state` varchar(64) DEFAULT NULL,
-  `browser` varchar(64) DEFAULT NULL,
-  `message` text,
-  `stackTrace` text,
-  `retryCount` int(11) DEFAULT '0',
-  `exceptionMap_guid` varchar(64) DEFAULT NULL,
-  `logURL` text,
-  PRIMARY KEY (`guid`)
+  `test_address` varchar(255) NOT NULL DEFAULT '',
+  `inserted_at` bigint(20) NOT NULL,
+  `expected_result` text,
+  `is_done` tinyint(1) DEFAULT '0',
+  `expires_at` bigint(20) DEFAULT NULL,
+  PRIMARY KEY (`guid`),
+  UNIQUE KEY `uuid` (`guid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
diff --git a/seleniumbase/fixtures/delayed_data_manager.py b/seleniumbase/fixtures/delayed_data_manager.py
@@ -4,82 +4,81 @@
 import uuid
 from seleniumbase.core.mysql import DatabaseManager
 
-DEFAULT_EXPIRATION = 1000 * 60 * 60 * 48
+DEFAULT_EXPIRATION = 1000 * 60 * 60 * 24  # A day later (in milliseconds)
 
 
 class DelayedTestStorage:
-    """ The database-calling methods of the Delayed Test Framework """
 
     @classmethod
-    def get_delayed_test_data(self, testcase_address, done=0):
-        """ This method queries the delayedTestData table in the DB and
+    def get_delayed_test_data(self, test_address, is_done=0):
+        """ This method queries the delayed_test_data table in the DB and
             then returns a list of rows with the matching parameters.
-            :param testcase_address: The ID (address) of the test case.
-            :param done: (0 for test not done or 1 for test done)
-            :returns: A list of rows found with the matching testcase_address.
+            :param test_address: The ID (address) of the test case.
+            :param is_done: (0 for test not done or 1 for test done)
+            :returns: A list of rows found with the matching test_address.
         """
         db = DatabaseManager()
-        query = """SELECT guid,testcaseAddress,insertedAt,expectedResult,done
-                   FROM delayedTestData
-                   WHERE testcaseAddress=%(testcase_address)s
-                   AND done=%(done)s"""
+        query = """SELECT guid,test_address,inserted_at,expected_result,is_done
+                   FROM delayed_test_data
+                   WHERE test_address=%(test_address)s
+                   AND is_done=%(is_done)s"""
         data = db.fetchall_query_and_close(
-            query, {"testcase_address": testcase_address,
-                    "done": done})
+            query, {"test_address": test_address,
+                    "is_done": is_done})
         if data:
             return data
         else:
-            logging.debug("Could not find any rows in delayedTestData.")
+            logging.debug("Could not find any rows in delayed_test_data.")
             logging.debug("DB Query = " + query %
-                          {"testcase_address": testcase_address, "done": done})
+                          {"test_address": test_address, "is_done": is_done})
             return []
 
     @classmethod
-    def insert_delayed_test_data(self, guid_, testcase_address,
-                                 expected_result, done=0,
+    def insert_delayed_test_data(self, guid_, test_address,
+                                 expected_result, is_done=0,
                                  expires_at=DEFAULT_EXPIRATION):
-        """ This method inserts rows into the delayedTestData table
+        """ This method inserts rows into the delayed_test_data table
             in the DB based on the given parameters where
             inserted_at (Date format) is automatically set in this method.
             :param guid_: The guid that is provided by the test case.
             (Format: str(uuid.uuid4()))
-            :param testcase_address: The ID (address) of the test case.
+            :param test_address: The ID (address) of the test case.
             :param expected_result: The result string of persistent data
             that will be stored in the DB.
-            :param done: (0 for test not done or 1 for test done)
+            :param is_done: (0 for test not done or 1 for test done)
             :returns: True (when no exceptions or errors occur)
         """
         inserted_at = int(time.time() * 1000)
 
         db = DatabaseManager()
-        query = """INSERT INTO delayedTestData(
-                   guid,testcaseAddress,insertedAt,
-                   expectedResult,done,expiresAt)
-                   VALUES (%(guid)s,%(testcaseAddress)s,%(inserted_at)s,
-                           %(expected_result)s,%(done)s,%(expires_at)s)"""
+        query = """INSERT INTO delayed_test_data(
+                   guid,test_address,inserted_at,
+                   expected_result,is_done,expires_at)
+                   VALUES (%(guid)s,%(test_address)s,%(inserted_at)s,
+                           %(expected_result)s,%(is_done)s,%(expires_at)s)"""
 
         db.execute_query_and_close(
             query, {"guid": guid_,
-                    "testcaseAddress": testcase_address,
+                    "test_address": test_address,
                     "inserted_at": inserted_at,
                     "expected_result": expected_result,
-                    "done": done,
+                    "is_done": is_done,
                     "expires_at": inserted_at + expires_at})
         return True
 
     @classmethod
     def set_delayed_test_to_done(self, guid_):
-        """ This method updates the delayedTestData table in the DB
+        """ This method updates the delayed_test_data table in the DB
             to set the test with the selected guid to done.
             :param guid_: The guid that is provided by the test case.
             (Format: str(uuid.uuid4()))
             :returns: True (when no exceptions or errors occur)
         """
         db = DatabaseManager()
-        query = """UPDATE delayedTestData
-                   SET done=TRUE
+        query = """UPDATE delayed_test_data
+                   SET is_done=TRUE
                    WHERE guid=%(guid)s
-                   AND done=FALSE"""
+                   AND is_done=FALSE"""
         db.execute_query_and_close(query, {"guid": guid_})
         return True
 
@@ -94,15 +93,15 @@ def get_delayed_results(self, test_id, seconds, set_done=True):
         in the DB to done.
         The results is a list of dicts where each list item contains
         item[0] = guid
-        item[1] = testcaseAddress
+        item[1] = test_address
         item[2] = seconds from epoch
         item[3] = expected results dict encoded in json
         :param test_id: the self.id() of the test
         :param seconds: the wait period until the data can be checked
         :returns: the results for a specific test where enough time has passed
         """
         delayed_test_data = DelayedTestStorage.get_delayed_test_data(
-            testcase_address=test_id)
+            test_address=test_id)
         now = int(time.time() * 1000)
         results_to_check = []
         if delayed_test_data is None:
diff --git a/seleniumbase/plugins/db_reporting_plugin.py b/seleniumbase/plugins/db_reporting_plugin.py
