Remove database code from singletest api

Author: bridadan

tools/README.md

@@ -38,9 +38,7 @@ Quick navigation:
 | `test`                | unit tests for tools                           |
 | `test_api.py`         | part of pre-greentea greentea                  |
 | `test_configs`        | configuration files used by `mbed test`        |
-| `test_db.py`          | part of pre-greentea greentea                  |
 | `test_exporters.py`   | part of pre-greentea greentea                  |
-| `test_mysql.py`       | part of pre-greentea greentea                  |
 | `tests.py`            | implementation of `mbed test --greentea`       |
 | `toolchains`          | API for calling the selected compiler          |
 | `utils.py`            | General purpose utilities like file moving     |

tools/singletest.py

@@ -65,7 +65,6 @@
 # Imports from TEST API
 from tools.test_api import SingleTestRunner
 from tools.test_api import singletest_in_cli_mode
-from tools.test_api import detect_database_verbose
 from tools.test_api import get_json_data_from_file
 from tools.test_api import get_avail_tests_summary_table
 from tools.test_api import get_default_test_options_parser
@@ -109,10 +108,6 @@ def get_version():
         print "Version %d.%d"% get_version()
         exit(0)
 
-    if opts.db_url and opts.verbose_test_configuration_only:
-        detect_database_verbose(opts.db_url)
-        exit(0)
-
     # Print summary / information about automation test status
     if opts.test_automation_report:
         print get_avail_tests_summary_table(platform_filter=opts.general_filter_regex)
@@ -227,7 +222,6 @@ def get_version():
                                    _clean=opts.clean,
                                    _parser=parser,
                                    _opts=opts,
-                                   _opts_db_url=opts.db_url,
                                    _opts_log_file_name=opts.log_file_name,
                                    _opts_report_html_file_name=opts.report_html_file_name,
                                    _opts_report_junit_file_name=opts.report_junit_file_name,

tools/test_api.py

@@ -57,7 +57,6 @@
 from tools.targets import TARGET_MAP, Target
 from tools.config import Config
 import tools.test_configs as TestConfig
-from tools.test_db import BaseDBAccess
 from tools.build_api import build_project, build_mbed_libs, build_lib
 from tools.build_api import get_target_supported_toolchains
 from tools.build_api import write_build_report
@@ -185,7 +184,6 @@ def __init__(self,
                  _clean=False,
                  _parser=None,
                  _opts=None,
-                 _opts_db_url=None,
                  _opts_log_file_name=None,
                  _opts_report_html_file_name=None,
                  _opts_report_junit_file_name=None,
@@ -244,7 +242,6 @@ def __init__(self,
         self.test_spec = _test_spec
 
         # Settings passed e.g. from command line
-        self.opts_db_url = _opts_db_url
         self.opts_log_file_name = _opts_log_file_name
         self.opts_report_html_file_name = _opts_report_html_file_name
         self.opts_report_junit_file_name = _opts_report_junit_file_name
@@ -284,21 +281,6 @@ def __init__(self,
         # File / screen logger initialization
         self.logger = CLITestLogger(file_name=self.opts_log_file_name)  # Default test logger
 
-        # Database related initializations
-        self.db_logger = factory_db_logger(self.opts_db_url)
-        self.db_logger_build_id = None # Build ID (database index of build_id table)
-        # Let's connect to database to set up credentials and confirm database is ready
-        if self.db_logger:
-            self.db_logger.connect_url(self.opts_db_url) # Save db access info inside db_logger object
-            if self.db_logger.is_connected():
-                # Get hostname and uname so we can use it as build description
-                # when creating new build_id in external database
-                (_hostname, _uname) = self.db_logger.get_hostname()
-                _host_location = os.path.dirname(os.path.abspath(__file__))
-                build_id_type = None if self.opts_only_build_tests is None else self.db_logger.BUILD_ID_TYPE_BUILD_ONLY
-                self.db_logger_build_id = self.db_logger.get_next_build_id(_hostname, desc=_uname, location=_host_location, type=build_id_type)
-                self.db_logger.disconnect()
-
     def dump_options(self):
         """ Function returns data structure with common settings passed to SingelTestRunner
             It can be used for example to fill _extra fields in database storing test suite single run data
@@ -307,8 +289,7 @@ def dump_options(self):
             or
             data_str = json.dumps(self.dump_options())
         """
-        result = {"db_url" : str(self.opts_db_url),
-                  "log_file_name" :  str(self.opts_log_file_name),
+        result = {"log_file_name" :  str(self.opts_log_file_name),
                   "shuffle_test_order" : str(self.opts_shuffle_test_order),
                   "shuffle_test_seed" : str(self.opts_shuffle_test_seed),
                   "test_by_names" :  str(self.opts_test_by_names),
@@ -416,27 +397,6 @@ def execute_thread_slice(self, q, target, toolchains, clean, test_ids, build_rep
 
             if self.opts_shuffle_test_order:
                 random.shuffle(test_map_keys, self.shuffle_random_func)
-                # Update database with shuffle seed f applicable
-                if self.db_logger:
-                    self.db_logger.reconnect();
-                    if self.db_logger.is_connected():
-                        self.db_logger.update_build_id_info(
-                            self.db_logger_build_id,
-                            _shuffle_seed=self.shuffle_random_func())
-                        self.db_logger.disconnect();
-
-            if self.db_logger:
-                self.db_logger.reconnect();
-                if self.db_logger.is_connected():
-                    # Update MUTs and Test Specification in database
-                    self.db_logger.update_build_id_info(
-                        self.db_logger_build_id,
-                        _muts=self.muts, _test_spec=self.test_spec)
-                    # Update Extra information in database (some options passed to test suite)
-                    self.db_logger.update_build_id_info(
-                        self.db_logger_build_id,
-                        _extra=json.dumps(self.dump_options()))
-                    self.db_logger.disconnect();
 
             valid_test_map_keys = self.get_valid_tests(test_map_keys, target, toolchain, test_ids, self.opts_include_non_automated)
             skipped_test_map_keys = self.get_skipped_tests(test_map_keys, valid_test_map_keys)
@@ -656,12 +616,6 @@ def execute(self):
                 self.execute_thread_slice(q, target, toolchains, clean, test_ids, self.build_report, self.build_properties)
                 q.get()
 
-        if self.db_logger:
-            self.db_logger.reconnect();
-            if self.db_logger.is_connected():
-                self.db_logger.update_build_id_info(self.db_logger_build_id, _status_fk=self.db_logger.BUILD_ID_STATUS_COMPLETED)
-                self.db_logger.disconnect();
-
         return self.test_summary, self.shuffle_random_seed, self.test_summary_ext, self.test_suite_properties_ext, self.build_report, self.build_properties
 
     def get_valid_tests(self, test_map_keys, target, toolchain, test_ids, include_non_automated):
@@ -885,9 +839,6 @@ def handle_mut(self, mut, data, target_name, toolchain_name, test_loops=1):
         mcu = mut['mcu']
         copy_method = mut.get('copy_method')        # Available board configuration selection e.g. core selection etc.
 
-        if self.db_logger:
-            self.db_logger.reconnect()
-
         selected_copy_method = self.opts_copy_method if copy_method is None else copy_method
 
         # Tests can be looped so test results must be stored for the same test
@@ -986,27 +937,10 @@ def handle_mut(self, mut, data, target_name, toolchain_name, test_loops=1):
                 single_test_result, target_name_unique, toolchain_name, test_id,
                 test_description, elapsed_time, single_timeout))
 
-            # Update database entries for ongoing test
-            if self.db_logger and self.db_logger.is_connected():
-                test_type = 'SingleTest'
-                self.db_logger.insert_test_entry(self.db_logger_build_id,
-                                                 target_name,
-                                                 toolchain_name,
-                                                 test_type,
-                                                 test_id,
-                                                 single_test_result,
-                                                 single_test_output,
-                                                 elapsed_time,
-                                                 single_timeout,
-                                                 test_index)
-
             # If we perform waterfall test we test until we get OK and we stop testing
             if self.opts_waterfall_test and single_test_result == self.TEST_RESULT_OK:
                 break
 
-        if self.db_logger:
-            self.db_logger.disconnect()
-
         return (self.shape_global_test_loop_result(test_all_result, self.opts_waterfall_test and self.opts_consolidate_waterfall_test),
                 target_name_unique,
                 toolchain_name,
@@ -1658,46 +1592,6 @@ def log_line(self, LogType, log_line, timestamp=True, line_delim='\n'):
                 pass
         return log_line_str
 
-
-def factory_db_logger(db_url):
-    """ Factory database driver depending on database type supplied in database connection string db_url
-    """
-    if db_url is not None:
-        from tools.test_mysql import MySQLDBAccess
-        connection_info = BaseDBAccess().parse_db_connection_string(db_url)
-        if connection_info is not None:
-            (db_type, username, password, host, db_name) = BaseDBAccess().parse_db_connection_string(db_url)
-            if db_type == 'mysql':
-                return MySQLDBAccess()
-    return None
-
-
-def detect_database_verbose(db_url):
-    """ uses verbose mode (prints) database detection sequence to check it database connection string is valid
-    """
-    result = BaseDBAccess().parse_db_connection_string(db_url)
-    if result is not None:
-        # Parsing passed
-        (db_type, username, password, host, db_name) = result
-        #print "DB type '%s', user name '%s', password '%s', host '%s', db name '%s'"% result
-        # Let's try to connect
-        db_ = factory_db_logger(db_url)
-        if db_ is not None:
-            print("Connecting to database '%s'..." % db_url)
-            db_.connect(host, username, password, db_name)
-            if db_.is_connected():
-                print("ok")
-                print("Detecting database...")
-                print(db_.detect_database(verbose=True))
-                print("Disconnecting...")
-                db_.disconnect()
-                print("done")
-        else:
-            print("Database type '%s' unknown" % db_type)
-    else:
-        print("Parse error: '%s' - DB Url error" % db_url)
-
-
 def get_module_avail(module_name):
     """ This function returns True if module_name is already imported module
     """
@@ -1987,10 +1881,6 @@ def get_default_test_options_parser():
                         type=int,
                         help='You can increase global timeout for each test by specifying additional test timeout in seconds')
 
-    parser.add_argument('--db',
-                        dest='db_url',
-                        help='This specifies what database test suite uses to store its state. To pass DB connection info use database connection string. Example: \'mysql://username:[email protected]/db_name\'')
-
     parser.add_argument('-l', '--log',
                         dest='log_file_name',
                         help='Log events to external file (note not all console entries may be visible in log file)')