def setUpClass(cls): cls.Session = sessionmaker() cls.engine = create_engine( 'postgresql+psycopg2://ostf:ostf@localhost/ostf' ) cls.Session.configure(bind=cls.engine, autocommit=True) session = cls.Session() discovery(path=TEST_PATH, session=session) cls.ext_id = 'fuel_plugin.tests.functional.dummy_tests.' cls.expected = { 'cluster': { 'id': 1, 'deployment_tags': set(['ha', 'rhel', 'nova_network']) }, 'test_sets': ['general_test', 'stopped_test', 'ha_deployment_test'], 'tests': [cls.ext_id + test for test in [ ('deployment_types_tests.ha_deployment_test.' 'HATest.test_ha_depl'), ('deployment_types_tests.ha_deployment_test.' 'HATest.test_ha_rhel_depl'), 'general_test.Dummy_test.test_fast_pass', 'general_test.Dummy_test.test_long_pass', 'general_test.Dummy_test.test_fast_fail', 'general_test.Dummy_test.test_fast_error', 'general_test.Dummy_test.test_fail_with_step', 'stopped_test.dummy_tests_stopped.test_really_long', 'stopped_test.dummy_tests_stopped.test_one_no_so_long', 'stopped_test.dummy_tests_stopped.test_not_long_at_all' ]] }
def main(): cli_args = cli_config.parse_cli() config = { "server": {"host": cli_args.host, "port": cli_args.port}, "dbpath": cli_args.dbpath, "debug": cli_args.debug, "debug_tests": cli_args.debug_tests, } logger.setup(log_file=cli_args.log_file) log = logging.getLogger(__name__) root = app.setup_app(config=config) if getattr(cli_args, "after_init_hook"): return nailgun_hooks.after_initialization_environment_hook() nose_discovery.discovery(cli_args.debug_tests) host, port = pecan.conf.server.host, pecan.conf.server.port srv = pywsgi.WSGIServer((host, int(port)), root) log.info("Starting server in PID %s", os.getpid()) log.info("serving on http://%s:%s", host, port) try: signal.signal(signal.SIGCHLD, signal.SIG_IGN) srv.serve_forever() except KeyboardInterrupt: pass
def setUp(self): # orm session wrapping config.init_config([]) self.connection = self.engine.connect() self.trans = self.connection.begin() self.Session.configure( bind=self.connection ) self.session = self.Session() test_sets = self.session.query(models.TestSet).all() # need this if start unit tests in conjuction with integration if not test_sets: discovery(path=TEST_PATH, session=self.session) mixins.cache_test_repository(self.session) # mocking # request mocking self.request_mock = MagicMock() self.request_patcher = patch( 'fuel_plugin.ostf_adapter.wsgi.controllers.request', self.request_mock ) self.request_patcher.start() # engine.get_session mocking self.request_mock.session = self.session
def test_get_proper_description(self): expected = { 'title': 'fake empty test', 'name': ('fuel_plugin.tests.functional.' 'dummy_tests.deployment_types_tests.' 'ha_deployment_test.HATest.test_ha_rhel_depl'), 'duration': '0sec', 'test_set_id': 'ha_deployment_test', 'cluster_id': self.fixtures['ha_deployment_test']['cluster_id'], 'deployment_tags': ['ha', 'rhel'] } nose_discovery.discovery( path='fuel_plugin.tests.functional.dummy_tests.deployment_types_tests.ha_deployment_test', deployment_info=self.fixtures['ha_deployment_test'] ) test = self.session.query(models.Test)\ .filter_by(name=expected['name'])\ .filter_by(cluster_id=expected['cluster_id'])\ .filter_by(test_set_id=expected['test_set_id'])\ .one() self.assertTrue( all( [ expected[key] == getattr(test, key) for key in expected.keys() ] ) )
def test_discovery_tests(self): expected = { 'test_set_id': 'ha_deployment_test', 'cluster_id': 1, 'results_count': 2, 'results_data': { 'names': [ 'fuel_plugin.tests.functional.dummy_tests.deployment_types_tests.ha_deployment_test.HATest.test_ha_rhel_depl', 'fuel_plugin.tests.functional.dummy_tests.deployment_types_tests.ha_deployment_test.HATest.test_ha_depl' ] } } nose_discovery.discovery( path='fuel_plugin.tests.functional.dummy_tests.deployment_types_tests.ha_deployment_test', deployment_info=self.fixtures['ha_deployment_test'] ) tests = self.session.query(models.Test)\ .filter_by(test_set_id=expected['test_set_id'])\ .filter_by(cluster_id=expected['cluster_id'])\ .all() self.assertTrue(len(tests) == expected['results_count']) for test in tests: self.assertTrue(test.name in expected['results_data']['names']) self.assertTrue( set(test.deployment_tags) .issubset(self.fixtures['ha_deployment_test']['deployment_tags']) )
def test_discovery(self, engine): engine.get_session().merge.side_effect = \ lambda *args, **kwargs: self.fixtures_iter.next() nose_discovery.discovery( path='fuel_plugin/tests/functional/dummy_tests') self.assertEqual(engine.get_session().merge.call_count, 2)
def test_get_proper_description(self, engine): ''' Checks whether retrived docsctrings from tests are correct (in this occasion -- full). Magic that is used here is based on using data that is stored deeply in passed to test method mock object. ''' #etalon data is list of docstrings of tests #of particular test set expected = { 'title': 'fast pass test', 'name': 'fuel_plugin.tests.functional.dummy_tests.general_test.Dummy_test.test_fast_pass', 'duration': '1sec', 'description': ' This is a simple always pass test\n ' } #mocking behaviour of afterImport hook from DiscoveryPlugin #so that another hook -- addSuccess could process data properly engine.get_session().merge = lambda arg: arg #following code provide mocking logic for #addSuccess hook from DiscoveryPlugin that #(mentioned logic) in turn allows us to #capture data about test object that are processed engine.get_session()\ .query()\ .filter_by()\ .update\ .return_value = None nose_discovery.discovery( path='fuel_plugin/tests/functional/dummy_tests' ) #now we can refer to captured test objects (not test_sets) in order to #make test comparison against etalon test_obj_to_compare = [ call[0][0] for call in engine.get_session().add.call_args_list if ( isinstance(call[0][0], models.Test) and call[0][0].name.rsplit('.')[-1] == 'test_fast_pass' ) ][0] self.assertTrue( all( [ expected[key] == test_obj_to_compare.__dict__[key] for key in expected.keys() ] ) )
def test_discovery(self, engine): engine.get_session().merge.side_effect = \ lambda *args, **kwargs: self.fixtures_iter.next() nose_discovery.discovery( path='fuel_plugin/tests/functional/dummy_tests' ) self.assertEqual(engine.get_session().merge.call_count, 2)
def main(): settings = Ostf_Config() cli_args = cli_config.parse_cli() config = { 'server': { 'host': settings.adapter.server_host or cli_args.host, 'port': settings.adapter.server_port or cli_args.port }, 'dbpath': settings.adapter.dbpath or cli_args.dbpath, 'debug': cli_args.debug, 'debug_tests': cli_args.debug_tests, 'lock_dir': settings.adapter.lock_dir or cli_args.lock_dir, 'nailgun': { 'host': settings.adapter.nailgun_host or cli_args.nailgun_host, 'port': settings.adapter.nailgun_port or cli_args.nailgun_port } } logger.setup(log_file=( settings.adapter.log_file or cli_args.log_file)) log = logging.getLogger(__name__) root = app.setup_app(config=config) if settings.adapter.after_init_hook or\ getattr(cli_args, 'after_init_hook'): return nailgun_hooks.after_initialization_environment_hook() with engine.contexted_session(pecan.conf.dbpath) as session: # performing cleaning of expired data (if any) in db mixins.clean_db(session) # discover testsets and their tests CORE_PATH = pecan.conf.debug_tests if \ pecan.conf.get('debug_tests') else 'fuel_health' nose_discovery.discovery(path=CORE_PATH, session=session) # cache needed data from test repository mixins.cache_test_repository(session) host, port = pecan.conf.server.host, pecan.conf.server.port srv = pywsgi.WSGIServer((host, int(port)), root) log.info('Starting server in PID %s', os.getpid()) log.info("serving on http://%s:%s", host, port) try: signal.signal(signal.SIGCHLD, signal.SIG_IGN) srv.serve_forever() except KeyboardInterrupt: pass
def test_get_proper_description(self, engine): ''' Checks whether retrived docsctrings from tests are correct (in this occasion -- full). Magic that is used here is based on using data that is stored deeply in passed to test method mock object. ''' #etalon data is list of docstrings of tests #of particular test set expected = { 'title': 'fast pass test', 'name': 'fuel_plugin.tests.functional.dummy_tests.general_test.Dummy_test.test_fast_pass', 'duration': '1sec', 'description': ' This is a simple always pass test\n ' } #mocking behaviour of afterImport hook from DiscoveryPlugin #so that another hook -- addSuccess could process data properly engine.get_session().merge = lambda arg: arg #following code provide mocking logic for #addSuccess hook from DiscoveryPlugin that #(mentioned logic) in turn allows us to #capture data about test object that are processed engine.get_session()\ .query()\ .filter_by()\ .update\ .return_value = None nose_discovery.discovery( path='fuel_plugin/tests/functional/dummy_tests') #now we can refer to captured test objects (not test_sets) in order to #make test comparison against etalon test_obj_to_compare = [ call[0][0] for call in engine.get_session().add.call_args_list if (isinstance(call[0][0], models.Test) and call[0][0].name.rsplit('.')[-1] == 'test_fast_pass') ][0] self.assertTrue( all([ expected[key] == test_obj_to_compare.__dict__[key] for key in expected.keys() ]))
def main(): cli_args = cli_config.parse_cli() config = { 'server': { 'host': cli_args.host, 'port': cli_args.port }, 'dbpath': cli_args.dbpath, 'debug': cli_args.debug, 'debug_tests': cli_args.debug_tests, 'nailgun': { 'host': cli_args.nailgun_host, 'port': cli_args.nailgun_port } } logger.setup(log_file=cli_args.log_file) log = logging.getLogger(__name__) root = app.setup_app(config=config) if getattr(cli_args, 'after_init_hook'): return nailgun_hooks.after_initialization_environment_hook() #performing cleaning of expired data (if any) in db clean_db() #discover testsets and their tests CORE_PATH = pecan.conf.debug_tests if \ pecan.conf.get('debug_tests') else 'fuel_health' discovery(path=CORE_PATH, session=engine.get_session()) #cache needed data from test repository cache_data() host, port = pecan.conf.server.host, pecan.conf.server.port srv = pywsgi.WSGIServer((host, int(port)), root) log.info('Starting server in PID %s', os.getpid()) log.info("serving on http://%s:%s", host, port) try: signal.signal(signal.SIGCHLD, signal.SIG_IGN) srv.serve_forever() except KeyboardInterrupt: pass
def setUpClass(cls): session_mock = Mock() session_mock.begin = TransactionBeginMock nose_discovery.discovery(path=TEST_PATH, session=session_mock) cls.test_sets = [ el[0][0] for el in session_mock.merge.call_args_list if isinstance(el[0][0], models.TestSet) ] cls.tests = [ el[0][0] for el in session_mock.merge.call_args_list if isinstance(el[0][0], models.Test) ]
def main(): ostf_config.init_config(sys.argv[1:]) logger.setup(log_file=CONF.adapter.log_file) log = logging.getLogger(__name__) log.info('Start app configuration') root = app.setup_app({}) # completely clean db (drop tables, constraints and types) # plus drop alembic_version table (needed if, for example, head migration # script was changed after applying) if CONF.clear_db: return nailgun_hooks.clear_db(CONF.adapter.dbpath) if CONF.after_initialization_environment_hook: return nailgun_hooks.after_initialization_environment_hook() with engine.contexted_session(CONF.adapter.dbpath) as session: # performing cleaning of expired data (if any) in db mixins.delete_db_data(session) log.info('Cleaned up database.') # discover testsets and their tests CORE_PATH = CONF.debug_tests or 'fuel_health' log.info('Performing nose discovery with {0}.'.format(CORE_PATH)) nose_discovery.discovery(path=CORE_PATH, session=session) # cache needed data from test repository mixins.cache_test_repository(session) log.info('Discovery is completed') host, port = CONF.adapter.server_host, CONF.adapter.server_port srv = pywsgi.WSGIServer((host, port), root) log.info('Starting server in PID %s', os.getpid()) log.info("serving on http://%s:%s", host, port) try: signal.signal(signal.SIGCHLD, signal.SIG_IGN) srv.serve_forever() except KeyboardInterrupt: pass
def main(): ostf_config.init_config(sys.argv[1:]) logger.setup(log_file=CONF.adapter.log_file) log = logging.getLogger(__name__) log.info('Start app configuration') root = app.setup_app({}) # completely clean db (drop tables, constraints and types) # plus drop alembic_version table (needed if, for example, head migration # script was changed after applying) if CONF.clear_db: return nailgun_hooks.clear_db(CONF.adapter.dbpath) if CONF.after_initialization_environment_hook: return nailgun_hooks.after_initialization_environment_hook() with engine.contexted_session(CONF.adapter.dbpath) as session: # performing cleaning of expired data (if any) in db mixins.delete_db_data(session) log.info('Cleaned up database.') # discover testsets and their tests CORE_PATH = CONF.debug_tests or 'fuel_health' log.info('Performing nose discovery with {0}.'.format(CORE_PATH)) nose_discovery.discovery(path=CORE_PATH, session=session) # cache needed data from test repository mixins.cache_test_repository(session) log.info('Discovery is completed') host, port = CONF.adapter.server_host, CONF.adapter.server_port srv = pywsgi.WSGIServer((host, port), root) log.info('Starting server in PID %s', os.getpid()) log.info("serving on http://%s:%s", host, port) try: signal.signal(signal.SIGCHLD, signal.SIG_IGN) srv.serve_forever() except KeyboardInterrupt: pass
def setUpClass(cls): session_mock = Mock() session_mock.begin = TransactionBeginMock nose_discovery.discovery( path=TEST_PATH, session=session_mock ) cls.test_sets = [ el[0][0] for el in session_mock.merge.call_args_list if isinstance(el[0][0], models.TestSet) ] cls.tests = [ el[0][0] for el in session_mock.merge.call_args_list if isinstance(el[0][0], models.Test) ]
def discovery_check(cluster): #get needed information from nailgun via series of #requests to nailgun api. At this time we need #info about deployment type(ha, non-ha), type of network #management (nova-network, quntum) and attributes that #indicate that savanna/murano is installed cluster_deployment_args = _get_cluster_depl_tags(cluster) cluster_data = { 'cluster_id': cluster, 'deployment_tags': cluster_deployment_args } session = engine.get_session() with session.begin(subtransactions=True): test_sets = session.query(models.TestSet)\ .filter_by(cluster_id=cluster)\ .all() if not test_sets: nose_discovery.discovery( path=CORE_PATH, deployment_info=cluster_data ) else: for testset in test_sets: deployment_tags = testset.deployment_tags deployment_tags = deployment_tags if deployment_tags else [] if not set(deployment_tags).issubset( cluster_data['deployment_tags'] ): #perform cascade deletion of testset #and corresponding to it tests and #testruns with their tests too session.query(models.TestSet)\ .filter_by(id=testset.id)\ .filter_by(cluster_id=testset.cluster_id)\ .delete() #perform final discovery for tests nose_discovery.discovery( path=CORE_PATH, deployment_info=cluster_data )
def setUp(self): #orm session wrapping self.connection = self.engine.connect() self.trans = self.connection.begin() self.Session.configure( bind=self.connection ) self.session = self.Session(autocommit=True) with self.session.begin(subtransactions=True): test_sets = self.session.query(models.TestSet).all() #need this if start unit tests in conjuction with integration if not test_sets: discovery(path=TEST_PATH, session=self.session) mixins.cache_test_repository(self.session) #mocking #request mocking self.request_mock = MagicMock() self.request_patcher = patch( 'fuel_plugin.ostf_adapter.wsgi.controllers.request', self.request_mock ) self.request_patcher.start() #pecan conf mocking self.pecan_conf_mock = MagicMock() self.pecan_conf_mock.nailgun.host = '127.0.0.1' self.pecan_conf_mock.nailgun.port = 8888 self.pecan_conf_patcher = patch( 'fuel_plugin.ostf_adapter.mixins.conf', self.pecan_conf_mock ) self.pecan_conf_patcher.start() #engine.get_session mocking self.request_mock.session = self.session
def test_discovery_testsets(self): expected = { 'id': 'ha_deployment_test', 'cluster_id': 1, 'deployment_tags': ['ha'] } nose_discovery.discovery( path='fuel_plugin.tests.functional.dummy_tests.deployment_types_tests.ha_deployment_test', deployment_info=self.fixtures['ha_deployment_test'] ) test_set = self.session.query(models.TestSet)\ .filter_by(id=expected['id'])\ .filter_by(cluster_id=expected['cluster_id'])\ .one() self.assertEqual( test_set.deployment_tags, expected['deployment_tags'] )
def setUp(self): super(TestTestRunsController, self).setUp() #test_runs depends on tests and test_sets data #in database so we must execute discovery function #in setUp in order to provide this data depl_info = { 'cluster_id': 1, 'deployment_tags': set([ 'ha', 'rhel' ]) } discovery(deployment_info=depl_info, path=TEST_PATH) self.testruns = [ { 'testset': 'ha_deployment_test', 'metadata': {'cluster_id': 1} } ] self.controller = controllers.TestrunsController()
def discovery_mock(**kwargs): kwargs['path'] = TEST_PATH return discovery(**kwargs)
def discovery(self): """Discover dummy tests used for testsing.""" mixins.TEST_REPOSITORY = [] nose_discovery.discovery(path=TEST_PATH, session=self.session) mixins.cache_test_repository(self.session) self.session.flush()
def discovery(self): """Discover dummy tests used for testsing.""" mixins.TEST_REPOSITORY = [] nose_discovery.discovery(path=TEST_PATH, session=self.session) mixins.cache_test_repository(self.session) self.session.flush()