test_db method naming

Author: mdmintz

README.md

@@ -643,25 +643,25 @@ The following example below (taken from the Delayed Test Data Manager) shows how
 import logging
 from seleniumbase.core.mysql import DatabaseManager
 
-def get_delayed_test_data(self, test_address, is_done=0):
+def get_divided_test_data(self, test_address, is_done=0):
     """ Returns a list of rows """
     db = DatabaseManager()
-    query = """SELECT guid,test_address,inserted_at,expected_result,is_done
-               FROM delayed_test_data
+    query = """SELECT guid,test_address,inserted_at,test_data,is_done
+               FROM divided_test_data
                WHERE test_address=%(test_address)s
                AND is_done=%(is_done)s"""
     data = db.fetchall_query(query, {"test_address":test_address, "is_done":is_done})
     if data:
         return data
     else:
-        logging.debug("Could not find any rows in delayed_test_data.")
+        logging.debug("Could not find any rows in divided_test_data.")
         logging.debug("DB Query = " + query % {"test_address":test_address, "is_done":is_done})
         return []
 ```
 
 Now you know how to pull data from your MySQL DB.
 
-Delayed Data usage example: If you scheduled an email to go out 3 hours from now and you wanted to check that the email gets received (but you don't want your test sitting idle for 3 hours) you can store the email credentials as a unique time-stamp for the email subject in the DB (along with a time for when it's safe for the email to be searched for) and then a later-running test can do the checking after the right amount of time has passed.
+Divided Test usage example: If you scheduled an email to go out 3 hours from now and you wanted to check that the email gets received (but you don't want your test sitting idle for 3 hours) you can store the email credentials as a unique time-stamp for the email subject in the DB (along with a time for when it's safe for the email to be searched for) and then a later-running test can do the checking after the right amount of time has passed.
 
 
 ### ![http://seleniumbase.com](https://cdn2.hubspot.net/hubfs/100006/images/super_logo_tiny.png "SeleniumBase") Wrap-Up

seleniumbase/core/create_db_tables.sql

@@ -29,15 +29,15 @@ CREATE TABLE `execution` (
   PRIMARY KEY (`guid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-# delayed_test_data table
+# divided_test_data table
 # -----------------------------------
-CREATE TABLE `delayed_test_data` (
+CREATE TABLE `divided_test_data` (
   `guid` varchar(64) NOT NULL DEFAULT '',
   `test_address` varchar(255) NOT NULL DEFAULT '',
   `inserted_at` bigint(20) NOT NULL,
-  `expected_result` text,
+  `test_data` text,
   `is_done` tinyint(1) DEFAULT '0',
-  `expires_at` bigint(20) DEFAULT NULL,
+  `wait_time` bigint(20) DEFAULT NULL,
   PRIMARY KEY (`guid`),
   UNIQUE KEY `uuid` (`guid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

seleniumbase/fixtures/delayed_data_manager.py

@@ -4,22 +4,34 @@
 import uuid
 from seleniumbase.core.mysql import DatabaseManager
 
-DEFAULT_EXPIRATION = 1000 * 60 * 60 * 24  # A day later (in milliseconds)
+DEFAULT_WAIT_TIME = 1000 * 60 * 60 * 24  # A day later (in milliseconds)
 
 
-class DelayedTestStorage:
+class DividedTestStorage:
+    """
+    When you need a large time delay between two parts of a test, you can break
+    the test up into two tests, and use the divided_test_data table of the
+    MySQL DB to hold onto important information until the second part of the
+    divided test is ready to complete the remainder of the test.
+
+    *** Example ***:
+    You've created an email-marketing tool that sends out a follow-up email in
+    exactly 24 hours. The first part of the test can schedule the follow-up
+    email while the second part of the test verifies that the follow-up email
+    was sent and received successfully after enough time has passed.
+    """
 
     @classmethod
-    def get_delayed_test_data(self, test_address, is_done=0):
-        """ This method queries the delayed_test_data table in the DB and
+    def get_divided_test_data(self, test_address, is_done=0):
+        """ This method queries the divided_test_data table in the test_db and
             then returns a list of rows with the matching parameters.
             :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,test_address,inserted_at,expected_result,is_done
-                   FROM delayed_test_data
+        query = """SELECT guid,test_address,inserted_at,test_data,is_done
+                   FROM divided_test_data
                    WHERE test_address=%(test_address)s
                    AND is_done=%(is_done)s"""
         data = db.query_fetch_all(
@@ -28,113 +40,112 @@ def get_delayed_test_data(self, test_address, is_done=0):
         if data:
             return data
         else:
-            logging.debug("Could not find any rows in delayed_test_data.")
+            logging.debug("Could not find any rows in divided_test_data.")
             logging.debug("DB Query = " + query %
                           {"test_address": test_address, "is_done": is_done})
             return []
 
     @classmethod
-    def insert_delayed_test_data(self, guid_, test_address,
-                                 expected_result, is_done=0,
-                                 expires_at=DEFAULT_EXPIRATION):
-        """ This method inserts rows into the delayed_test_data table
+    def insert_divided_test_data(self, guid_, test_address,
+                                 test_data, is_done=0,
+                                 wait_time=DEFAULT_WAIT_TIME):
+        """ This method inserts rows into the divided_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 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 test_data: Additional data to store for the test.
             :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 delayed_test_data(
+        query = """INSERT INTO divided_test_data(
                    guid,test_address,inserted_at,
-                   expected_result,is_done,expires_at)
+                   test_data,is_done,wait_time)
                    VALUES (%(guid)s,%(test_address)s,%(inserted_at)s,
-                           %(expected_result)s,%(is_done)s,%(expires_at)s)"""
+                           %(test_data)s,%(is_done)s,%(wait_time)s)"""
 
         db.execute_query(
             query, {"guid": guid_,
                     "test_address": test_address,
                     "inserted_at": inserted_at,
-                    "expected_result": expected_result,
+                    "test_data": test_data,
                     "is_done": is_done,
-                    "expires_at": inserted_at + expires_at})
+                    "wait_time": inserted_at + wait_time})
         return True
 
     @classmethod
-    def set_delayed_test_to_done(self, guid_):
-        """ This method updates the delayed_test_data table in the DB
+    def set_divided_test_to_done(self, guid_):
+        """ This method updates the divided_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 delayed_test_data
+        query = """UPDATE divided_test_data
                    SET is_done=TRUE
                    WHERE guid=%(guid)s
                    AND is_done=FALSE"""
         db.execute_query(query, {"guid": guid_})
         return True
 
 
-class DelayedTestAssistant:
+class DividedTestAssistant:
     """ Some methods for assisting tests (that don't call the DB directly) """
 
     @classmethod
-    def get_delayed_results(self, test_id, seconds, set_done=True):
+    def get_divided_test_results(self, test_id, seconds, set_done=True):
         """
-        This method gets the delayed_test_data and sets the applicable rows
+        This method gets the divided_test data and sets the applicable rows
         in the DB to done.
         The results is a list of dicts where each list item contains
         item[0] = guid
         item[1] = test_address
-        item[2] = seconds from epoch
-        item[3] = expected results dict encoded in json
+        item[2] = time (in seconds from Epoch)
+        item[3] = test data 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(
+        divided_test_data = DividedTestStorage.get_divided_test_data(
             test_address=test_id)
         now = int(time.time() * 1000)
         results_to_check = []
-        if delayed_test_data is None:
+        if divided_test_data is None:
             return results_to_check
-        for item in delayed_test_data:
+        for item in divided_test_data:
             if item[2] < now - (seconds * 1000):
                 results_to_check.append(item)
                 if set_done:
-                    DelayedTestStorage.set_delayed_test_to_done(item[0])
+                    DividedTestStorage.set_divided_test_to_done(item[0])
         return results_to_check
 
     @classmethod
-    def store_delayed_data(self, test_id, expected_result_dict,
-                           expires_at=DEFAULT_EXPIRATION):
+    def store_divided_test_data(self, test_id, test_data_dict,
+                                wait_time=DEFAULT_WAIT_TIME):
         """
-        Loads the dictionary of information into the delayed test database
+        Loads the dictionary of information into the divided_test_data table
         :param test_id: the self.id() of the test
-        :param expected_result_dict: a dictionary of what's to be checked later
+        :param test_data_dict: a dictionary of data to store for later
         """
-        expected_result_json = json.JSONEncoder().encode(expected_result_dict)
-        DelayedTestStorage.insert_delayed_test_data(str(uuid.uuid4()),
+        test_data_json = json.JSONEncoder().encode(test_data_dict)
+        DividedTestStorage.insert_divided_test_data(str(uuid.uuid4()),
                                                     test_id,
-                                                    expected_result_json,
+                                                    test_data_json,
                                                     0,
-                                                    expires_at)
+                                                    wait_time)
 
     @classmethod
     def set_test_done(self, test_guid):
-        """ This method calls set_delayed_test_to_done to set a
+        """ This method calls set_divided_test_to_done to set a
             row in the db to done.
             :param test_guid: The guid that is provided by the test.
             (Format: str(uuid.uuid4()))
             :returns: True (when no exceptions or errors occur)
         """
-        DelayedTestStorage.set_delayed_test_to_done(test_guid)
+        DividedTestStorage.set_divided_test_to_done(test_guid)
         return True