class TestKEngineOutOfTheBox(TestFunctionalCase): @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["ccmy_sand_seed"], ProjectsSanityData()) def test_ccmy_sand_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['dcdf4bd0-aba7-43c8-acfd-b87669fc57d2'] for session in sessions: data_provider.load_session_data(session) output = Output() CCMY_SANDCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(""" SELECT * FROM report.kpi_results """) kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_table_row_count(self, table, row_count): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute("""SELECT * FROM {table}""".format(table=table)) self.assertEquals(cursor.rowcount, row_count)
class TestShareOfDisplay(TestFunctionalCase): _project1 = TestProjectsNames().TEST_PROJECT_1 data_provider = None seeder = Seeder() patcher = None @classmethod def mock_empty_spaces(cls): cls.patcher = patch('{}.EmptySpaceKpiGenerator'.format(MOCK_PATH)) cls.patcher.start() @classmethod @seeder.seed(['sql_sod'], SodTestSeedData()) def setUpClass(cls): super(TestShareOfDisplay, cls).setUpClass() cls._data_input_project_1 = InsertDataIntoMySqlProjectSOD( cls._project1) cls.mock_empty_spaces() @classmethod def tearDownClass(cls): cls.seeder.stop() cls.patcher.stop() def assert_actual_to_expected_from_file(self, actual, test): with open(os.path.dirname(__file__) + '/expected.pickle', 'rb') as handle: b = pickle.load(handle) expected = b[test] result = actual.equals(expected) self.assertEqual(result, True)
class TestKEngineOutOfTheBox(TestFunctionalCase): @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["lionjp_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_lionjp_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['5C4B4887-B68E-4FDC-9C78-4866D746489A'] for session in sessions: data_provider.load_session_data(session) output = Output() Calculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @skip('sup') @seeder.seed(["sanofihk_seed"], ProjectsSanityData()) def test_sanofihk_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['265da56b-c7f4-4960-bca2-1ff169a57916'] for session in sessions: data_provider.load_session_data(session) output = Output() SANOFIHKCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestShareOfDisplay(TestFunctionalCase): _project1 = TestProjectsNames().TEST_PROJECT_1 config_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'k-engine-test.config') seeder = Seeder() _data_input_project_1 = None patcher = None @classmethod def mock_empty_spaces(cls): cls.patcher = patch('{}.EmptySpaceKpiGenerator'.format(MOCK_PATH)) cls.patcher.start() @classmethod @seeder.seed(['sql_sod'], SodTestSeedData()) def setUpClass(cls): super(TestShareOfDisplay, cls).setUpClass() cls.mock_empty_spaces() cls._data_input_project_1 = InsertDataIntoMySqlProjectSOD( cls._project1) cls._data_input_project_1.update_all_scenes_to_same_session() with TempTestConfig(conf_file=cls.config_file): data_provider = KEngineDataProvider(cls._project1) data_provider.load_session_data( '2b14c6c6-1458-4c3c-96a2-1ae20824f054') calculate_share_of_display(None, '2b14c6c6-1458-4c3c-96a2-1ae20824f054', data_provider=data_provider) data_provider.project_connector.db.commit() @classmethod def tearDownClass(cls): cls.seeder.stop() cls.patcher.stop()
class TestCcus(TestFunctionalCase): seeder = Seeder() def set_up(self): super(TestCcus, self).set_up() remove_cache_and_storage() self.project_name = ProjectsSanityData.project_name self.session_uid = '8395fc95-465b-47c2-ad65-6d10de13cd75' @property def import_path(self): return 'Projects.CCUS.Pillars.Utils.KPIToolBox' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') # functional tests - testing the output of some of the methods @seeder.seed(["mongodb_products_and_brands_seed", "ccus_seed"], ProjectsSanityData()) def test_round_result_outpute(self): output = Output() data_provider = KEngineDataProvider(self.project_name) data_provider.load_session_data(self.session_uid) commonv2 = Common(data_provider) self.tool_box = PillarsPROGRAMSToolBox(data_provider, output, commonv2)
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_old_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_new_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_scene_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.scene_kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["twegau_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_twegau_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = {'000E4051-2111-4220-9991-3D3FA1102540': []} for session in sessions.keys(): data_provider.load_session_data(str(session)) output = Output() Calculations(data_provider, output).run_project_calculations()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() # silent test, diageomx are no longer using those templates and the test is failing # self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @patch( 'KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.get_latest_directory_date_from_cloud', return_value='2018-05-18') @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.save_latest_templates') @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.download_template', return_value=mpa) @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.download_template', return_value=products) @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.download_template', return_value=position) @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.download_template', return_value=posm) @seeder.seed(["mongodb_products_and_brands_seed", "diageomx_seed"], ProjectsSanityData()) def test_diageomx_sanity(self, x, y, json, json2, json3, json4): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['fd7d2a19-3a1c-40fd-a7d1-3a01260392d1'] for session in sessions: data_provider.load_session_data(session) output = Output() DIAGEOMXCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestDiageotw(TestFunctionalCase): seeder = Seeder() def set_up(self): super(TestDiageotw, self).set_up() self.project_name = ProjectsSanityData.project_name self.output = Output() self.mock_object('save_latest_templates', path='KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox') self.session_uid = 'B1F11D51-DC00-4FDB-86E4-B389530C66DB' remove_cache_and_storage()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() self.mock_object( 'save_latest_templates', path= 'KPIUtils.GlobalProjects.DIAGEO.Utils.TemplatesUtil.TemplateHandler' ) self.mock_object( 'download_template', path= 'KPIUtils.GlobalProjects.DIAGEO.Utils.TemplatesUtil.TemplateHandler' ) remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): """tests if get results after running the KPIs""" connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() # @seeder.seed(["mongodb_products_and_brands_seed", "diageoco_seed"], ProjectsSanityData()) @skip('Will be restored soon') def test_diageoco_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['31fed918-37f0-449e-903b-be8ea233c80d'] for session in sessions: data_provider.load_session_data(session) output = Output() DIAGEOCOCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() from Tests.TestUtils import remove_cache_and_storage remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @patch( 'KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.get_latest_directory_date_from_cloud', return_value='2018-02-20') @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.save_latest_templates') @patch('KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox.download_template', return_value=diageoau_template) @seeder.seed(["mongodb_products_and_brands_seed", "diageoau_seed"], ProjectsSanityData()) def test_diageoau_sanity(self, x, y, json): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['A63E6C16-1833-484F-A838-424370AD3303'] for session in sessions: data_provider.load_session_data(session) output = Output() DIAGEOAUCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestDiageopt(TestFunctionalCase): seeder = Seeder() def set_up(self): super(TestDiageopt, self).set_up() self.project_name = ProjectsSanityData.project_name self.output = Output() self.session_uid = '963D013D-EEB6-48DF-B8EC-06C8E0C2AA6C' remove_cache_and_storage() @property def import_path(self): return 'Projects.DIAGEOPT.Utils.KPIToolBox' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config')
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() self.mock_object('save_latest_templates', path='KPIUtils.DIAGEO.ToolBox.DIAGEOToolBox') self.mock_object( 'save_level2_and_level3', path='Projects.PENAFLORAR.Utils.KPIToolBox.PENAFLORARToolBox') remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["mongodb_products_and_brands_seed", "penaflorar_seed"], ProjectsSanityData()) def test_penaflorar_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['0949f439-185e-48c1-bfc1-8a1230413ef2'] for session in sessions: data_provider.load_session_data(session) output = Output() PENAFLORARCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestDiageomx(TestFunctionalCase): seeder = Seeder() def set_up(self): self.project_name = ProjectsSanityData.project_name self.output = Output() self.session_uid = '8e5c105e-5457-4c50-a934-7324706c1c29' def tear_down(self): pass @property def import_path(self): return 'Projects.DIAGEOMX.Utils.KPIToolBox' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config')
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @patch('Projects.HEINEKENCN_SAND.Utils.ToolBox.HandleTemplate.get_latest_directory_date_from_cloud', return_value='2018-05-18') @patch('Projects.HEINEKENCN_SAND.Utils.ToolBox.HandleTemplate.save_latest_templates') @patch('Projects.HEINEKENCN_SAND.Utils.ToolBox.HandleTemplate.download_template', return_value=availability) @seeder.seed(["heinekencn_sand_seed"], ProjectsSanityData()) def test_heinekencn_sand_sanity(self, x, y, json): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['f7c3b29d-a5fc-457e-be65-0bae8b7f7202'] for session in sessions: data_provider.load_session_data(session) output = Output() HEINEKENCN_SANDCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals( len(kpi_results), -1 ) # check where results are stored ? kpi_level_2_results/kpi_results connector.disconnect_rds() @seeder.seed(["rnbde_sand_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_rnbde_sand_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['a39f79eb-4559-4eac-83fb-39399707f005'] for session in sessions: data_provider.load_session_data(session) output = Output() RNBDECalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() # TODO: FIX SANITY TEST @skip('Test failed in master') @seeder.seed(["mongodb_products_and_brands_seed", "ccus_seed"], ProjectsSanityData()) def test_ccus_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['8395fc95-465b-47c2-ad65-6d10de13cd75'] for session in sessions: data_provider.load_session_data(session) output = Output() CCUSCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["millercoors_seed"], ProjectsSanityData()) def test_millercoors_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = ['56110CA1-4C2A-4652-BDCB-463CCDA65AB6'] for session in sessions: data_provider.load_session_data(session) output = Output() MILLERCOORSCalculations(data_provider, output).run_project_calculations() self._assert_kpi_results_filled()
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_old_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_new_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_scene_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.scene_kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["pepsicouk_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_pepsicouk_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = { 'aee71e4d-cdd1-4474-803e-ef834d24871d': [94402], '961edfb7-ae52-40a7-ab39-45064f8c554d': [92747], 'be03f331-a509-4ef5-99a0-a1807fc96b71': [93375] } for session in sessions.keys(): data_provider.load_session_data(str(session)) output = Output() PEPSICOUKCalculations(data_provider, output).run_project_calculations() # self._assert_old_tables_kpi_results_filled() self._assert_new_tables_kpi_results_filled() for scene in sessions[session]: data_provider.load_scene_data(str(session), scene_id=scene) PEPSICOUKSceneCalculations(data_provider).calculate_kpis() self._assert_scene_tables_kpi_results_filled()
class PsSanityTestsFuncs(TestFunctionalCase): seeder = Seeder() def set_up(self): super(PsSanityTestsFuncs, self).set_up() remove_cache_and_storage() self.user = os.environ.get('USER') @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') def _assert_custom_scif_table_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() #cursor = connector.db.cursor(MySQLdb.cursors.DictCursor) cursor.execute(''' SELECT * FROM pservice.custom_scene_item_facts ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_old_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() #cursor = connector.db.cursor(MySQLdb.cursors.DictCursor) cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_new_tables_kpi_results_filled(self, distinct_kpis_num=None, list_of_kpi_names=None): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() #cursor = connector.db.cursor(MySQLdb.cursors.DictCursor) cursor.execute(''' SELECT kl2.pk, kl2.client_name, kl2r.kpi_level_2_fk, kl2r.result FROM report.kpi_level_2_results kl2r left join static.kpi_level_2 kl2 on kpi_level_2_fk = kl2.pk ''') kpi_results = cursor.fetchall() df = pd.DataFrame(list(kpi_results), columns=[col[0] for col in cursor.description]) if distinct_kpis_num: self.assertEquals(df['kpi_level_2_fk'].unique().__len__(), distinct_kpis_num) else: self.assertNotEquals(len(kpi_results), 0) if list_of_kpi_names: existing_results = df['client_name'].unique() result = all(elem in existing_results for elem in list_of_kpi_names) self.assertTrue(result) connector.disconnect_rds() def _assert_scene_tables_kpi_results_filled(self, distinct_kpis_num=None): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() #cursor = connector.db.cursor(MySQLdb.cursors.DictCursor) cursor.execute(''' SELECT * FROM report.scene_kpi_results ''') kpi_results = cursor.fetchall() if distinct_kpis_num: df = pd.DataFrame(list(kpi_results), columns=[col[0] for col in cursor.description]) self.assertEquals(df['kpi_level_2_fk'].unique().__len__(), distinct_kpis_num) else: self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_test_results_matches_reality(self, kpi_results, ignore_kpis=None): real_results = pd.DataFrame(kpi_results) if ignore_kpis: real_results = real_results[~real_results['client_name'].isin(ignore_kpis)] connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() #cursor = connector.db.cursor(MySQLdb.cursors.DictCursor) cursor.execute(""" SELECT distinct kpi.type, kpi.client_name, res.session_fk, res.kpi_level_2_fk, numerator_id, denominator_id, context_id, numerator_result, denominator_result, result FROM report.kpi_level_2_results res LEFT JOIN static.kpi_level_2 kpi ON kpi.pk = res.kpi_level_2_fk LEFT JOIN probedata.session ses ON ses.pk = res.session_fk """) kpi_results = cursor.fetchall() self.assertFalse(len(kpi_results) == 0) kpi_results = pd.DataFrame(list(kpi_results), columns=[col[0] for col in cursor.description]) merged_results = pd.merge(real_results, kpi_results, on=['session_fk', 'kpi_level_2_fk', 'numerator_id', 'denominator_id', 'context_id'], how="left") merged_results = merged_results.fillna(0) wrong_results = merged_results[(merged_results['result_x'] != merged_results['result_y']) | (merged_results['numerator_result_x'] != merged_results['numerator_result_y']) | (merged_results['denominator_result_x'] != merged_results['denominator_result_y'])] correct_results = merged_results[~merged_results.index.isin(wrong_results.index)] wrong_kpis_without_duplicates = list(set(wrong_results['kpi_level_2_fk']) - set(correct_results['kpi_level_2_fk'])) wrong_results = wrong_results[wrong_results['kpi_level_2_fk'].isin(wrong_kpis_without_duplicates)] if not wrong_results.empty: try: error_str = "The following KPIs had wrong results: \n" for i, res in wrong_results.iterrows(): error_str += ("session_fk: {0}, kpi_level_2_fk: {1}, client_name: {2}, numerator_id: {3}, " "denominator_id: {4}, context_id: {5}, seed_result: {6}, db_actual_result: {7}, " "seed_numerator_result: {8}, db_numerator_result: {9}, " "seed_denominator_result: {10}, db_denominator_result: {11}. " "\n""".format(str(res['session_fk']), str(res['kpi_level_2_fk']), str(res['client_name_x']), str(res['numerator_id']), str(res['denominator_id']), str(res['context_id']), str(res['result_y']), str(res['result_x']), str(res['numerator_result_y']), str(res['numerator_result_x']), str(res['denominator_result_y']), str(res['denominator_result_x']))) Log.info(error_str) except Exception as e: Log.warning("Couldn't log differences, failed with error: {}".format(e)) self.assertTrue(wrong_results.empty) def _assert_DIAGEO_test_results_matches_reality(self, kpi_results, ignore_kpis=None): self._assert_test_results_matches_reality(kpi_results, ignore_kpis) return def _assert_SANOFI_test_results_matches_reality(self, kpi_results, ignore_kpis=None): self._assert_test_results_matches_reality(kpi_results, ignore_kpis) return
class Test_PEPSICOUKScene(TestFunctionalCase): seeder = Seeder() @property def import_path(self): return 'Projects.PEPSICOUK.Utils.KPISceneToolBox' def set_up(self): super(Test_PEPSICOUKScene, self).set_up() self.mock_data_provider() self.data_provider_mock.project_name = 'Test_Project_1' self.data_provider_mock.rds_conn = MagicMock() self.db_users_mock = self.mock_db_users() self.project_connector_mock = self.mock_project_connector() self.mock_common_project_connector_mock = self.mock_common_project_connector( ) self.static_kpi_mock = self.mock_static_kpi() self.session_info_mock = self.mock_session_info() # self.probe_group_mock = self.mock_probe_group() self.custom_entity_data_mock = self.mock_custom_entity_data() self.on_display_products_mock = self.mock_on_display_products() self.full_store_info = self.mock_store_data() self.exclusion_template_mock = self.mock_template_data() self.output = MagicMock() self.session_info_mock = self.mock_session_info() self.external_targets_mock = self.mock_kpi_external_targets_data() self.kpi_result_values_mock = self.mock_kpi_result_value_table() self.kpi_scores_values_mock = self.mock_kpi_score_value_table() self.mock_all_products() self.mock_all_templates() # self.mock_block() # self.mock_adjacency() self.mock_position_graph() self.mock_position_graph_block() self.mock_position_graph_adjacency() self.mock_project_connector_base_calc() def mock_position_graph(self): self.mock_object( 'PositionGraphs', path='KPIUtils_v2.Calculations.AssortmentCalculations') def mock_position_graph_block(self): self.mock_object('PositionGraphs', path='KPIUtils_v2.Calculations.BlockCalculations') def mock_position_graph_adjacency(self): self.mock_object('PositionGraphs', path='KPIUtils_v2.Calculations.AdjacencyCalculations') def mock_project_connector_base_calc(self): self.mock_object('PSProjectConnector', path='KPIUtils_v2.Calculations.BaseCalculations') self.mock_object('PSProjectConnector', path='KPIUtils_v2.GlobalDataProvider.PsDataProvider') def mock_store_data(self): store_data = self.mock_object( 'PEPSICOUKCommonToolBox.get_store_data_by_store_id') store_data.return_value = DataTestUnitPEPSICOUK.store_data return store_data.return_value # def mock_block(self): # self.mock_object('Block') # # def mock_adjacency(self): # self.mock_object('Adjancency') def mock_probe_group(self, data): probe_group = self.mock_object('PEPSICOUKSceneToolBox.get_probe_group') probe_group.return_value = data.where(data.notnull(), None) return probe_group.return_value def mock_data_provider(self): self.data_provider_mock = MagicMock() # return self._data_provider self.data_provider_data_mock = {} def get_item(key): return self.data_provider_data_mock[ key] if key in self.data_provider_data_mock else MagicMock() self.data_provider_mock.__getitem__.side_effect = get_item def mock_db_users(self): return self.mock_object('DbUsers', path='KPIUtils_v2.DB.CommonV2'), \ self.mock_object('DbUsers', path='KPIUtils_v2.Calculations.BaseCalculations') def mock_project_connector(self): return self.mock_object('PSProjectConnector') def mock_common_project_connector(self): return self.mock_object('PSProjectConnector', path='KPIUtils_v2.DB.CommonV2') def mock_session_info(self): return self.mock_object('SessionInfo', path='Trax.Algo.Calculations.Core.Shortcuts') def mock_static_kpi(self): static_kpi = self.mock_object('Common.get_kpi_static_data', path='KPIUtils_v2.DB.CommonV2') static_kpi.return_value = DataTestUnitPEPSICOUK.kpi_static_data return static_kpi.return_value def mock_custom_entity_data(self): custom_entities = self.mock_object( 'PEPSICOUKCommonToolBox.get_custom_entity_data', path='Projects.PEPSICOUK.Utils.CommonToolBox') custom_entities.return_value = DataTestUnitPEPSICOUK.custom_entity return custom_entities.return_value def mock_on_display_products(self): on_display_products = self.mock_object( 'PEPSICOUKCommonToolBox.get_on_display_products', path='Projects.PEPSICOUK.Utils.CommonToolBox') on_display_products.return_value = DataTestUnitPEPSICOUK.on_display_products return on_display_products.return_value def mock_template_data(self): template_df = pd.read_excel( DataTestUnitPEPSICOUK.exclusion_template_path) template_data_mock = self.mock_object( 'PEPSICOUKCommonToolBox.get_exclusion_template_data', path='Projects.PEPSICOUK.Utils.CommonToolBox') template_data_mock.return_value = template_df return template_data_mock.return_value def mock_kpi_external_targets_data(self): # print DataTestUnitPEPSICOUK.external_targets external_targets_df = pd.read_excel( DataTestUnitPEPSICOUK.external_targets) external_targets = self.mock_object( 'PEPSICOUKCommonToolBox.get_all_kpi_external_targets', path='Projects.PEPSICOUK.Utils.CommonToolBox') external_targets.return_value = external_targets_df return external_targets.return_value def mock_kpi_result_value_table(self): kpi_result_value = self.mock_object( 'PEPSICOUKCommonToolBox.get_kpi_result_values_df', path='Projects.PEPSICOUK.Utils.CommonToolBox') kpi_result_value.return_value = DataTestUnitPEPSICOUK.kpi_results_values_table return kpi_result_value.return_value def mock_kpi_score_value_table(self): kpi_score_value = self.mock_object( 'PEPSICOUKCommonToolBox.get_kpi_result_values_df', path='Projects.PEPSICOUK.Utils.CommonToolBox', ) kpi_score_value.return_value = DataTestUnitPEPSICOUK.kpi_scores_values_table return kpi_score_value.return_value def mock_all_products(self): self.data_provider_data_mock['all_products'] = pd.read_excel( DataTestUnitPEPSICOUK.test_case_1, sheetname='all_products') def mock_all_templates(self): self.data_provider_data_mock[ 'all_templates'] = DataTestUnitPEPSICOUK.all_templates def mock_scene_item_facts(self, data): self.data_provider_data_mock['scene_item_facts'] = data.where( data.notnull(), None) def mock_match_product_in_scene(self, data): self.data_provider_data_mock['matches'] = data.where( data.notnull(), None) def mock_block_results(self, data): block_results = self.mock_object( 'Block.network_x_block_together', path='KPIUtils_v2.Calculations.BlockCalculations') block_results.side_effect = data return # def mock_adjacency_results(self, data): # adjacency_results = self.mock_object('Adjancency.network_x_adjacency_calculation', # path='KPIUtils_v2.Calculations.AdjacencyCalculations') # adjacency_results.return_value = data # return def mock_adjacency_results(self, data): adjacency_results = self.mock_object( 'Adjancency._is_block_adjacent', path='KPIUtils_v2.Calculations.AdjacencyCalculations') adjacency_results.side_effect = data return def create_scene_scif_matches_stitch_groups_data_mocks( self, test_case_file_path, scene_number): scif_test_case = pd.read_excel(test_case_file_path, sheetname='scif') matches_test_case = pd.read_excel(test_case_file_path, sheetname='matches') scif_scene = scif_test_case[scif_test_case['scene_fk'] == scene_number] matches_scene = matches_test_case[matches_test_case['scene_fk'] == scene_number] self.mock_scene_item_facts(scif_scene) self.mock_match_product_in_scene(matches_scene) probe_group = self.mock_probe_group( pd.read_excel(test_case_file_path, sheetname='stitch_groups')) return probe_group, matches_scene, scif_scene def test_excluded_matches(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) expected_result = set(matches[~(matches['Out'].isnull())] ['probe_match_fk'].values.tolist()) self.assertItemsEqual(expected_result, scene_tb.excluded_matches) def test_main_calculation_does_not_happen_if_location_secondary_shelf( self): probe_group, matches, scene = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 3) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.main_function() self.assertTrue(scene_tb.kpi_results.empty) def test_calculate_number_of_facings_and_linear_space(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_number_of_facings_and_linear_space() expected_list = [] expected_list.append({'kpi_fk': 321, 'numerator': 1, 'result': 7}) expected_list.append({'kpi_fk': 322, 'numerator': 1, 'result': 70}) expected_list.append({'kpi_fk': 321, 'numerator': 2, 'result': 6}) expected_list.append({'kpi_fk': 322, 'numerator': 2, 'result': 30}) expected_list.append({'kpi_fk': 321, 'numerator': 3, 'result': 8}) expected_list.append({'kpi_fk': 322, 'numerator': 3, 'result': 120}) expected_list.append({'kpi_fk': 321, 'numerator': 4, 'result': 18}) expected_list.append({'kpi_fk': 322, 'numerator': 4, 'result': 120}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) def test_calculate_number_of_bays_and_shelves(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_number_of_bays_and_shelves() expected_list = [] expected_list.append({'kpi_fk': 323, 'numerator': 2, 'result': 2}) expected_list.append({'kpi_fk': 324, 'numerator': 2, 'result': 6}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) def test_get_scene_bay_max_shelves_retrieves_expected_df_in_case_of_8_shelves( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 2) expected_result = pd.DataFrame([{ u'kpi_level_2_fk': 304, u'type': PEPSICOUKSceneToolBox.PLACEMENT_BY_SHELF_NUMBERS_TOP, u'No of Shelves in Fixture (per bay) (key)': 8, u'Shelves From Bottom To Include (data)': '7,8', u'shelves_all_placements': '7,8,5,6,3,4,1,2' }, { u'kpi_level_2_fk': 305, u'type': 'Placement by shelf numbers_Eye', u'No of Shelves in Fixture (per bay) (key)': 8, u'Shelves From Bottom To Include (data)': '5,6', u'shelves_all_placements': '7,8,5,6,3,4,1,2' }, { u'kpi_level_2_fk': 306, u'type': 'Placement by shelf numbers_Middle', u'No of Shelves in Fixture (per bay) (key)': 8, u'Shelves From Bottom To Include (data)': '3,4', u'shelves_all_placements': '7,8,5,6,3,4,1,2' }, { u'kpi_level_2_fk': 307, u'type': 'Placement by shelf numbers_Bottom', u'No of Shelves in Fixture (per bay) (key)': 8, u'Shelves From Bottom To Include (data)': '1,2', u'shelves_all_placements': '7,8,5,6,3,4,1,2' }]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) external_targets = scene_tb.commontools.all_targets_unpacked shelf_placmnt_targets = external_targets[ external_targets['operation_type'] == scene_tb.SHELF_PLACEMENT] if not shelf_placmnt_targets.empty: bay_max_shelves = scene_tb.get_scene_bay_max_shelves( shelf_placmnt_targets) bay_max_shelves = bay_max_shelves[[ 'kpi_level_2_fk', 'type', 'No of Shelves in Fixture (per bay) (key)', 'Shelves From Bottom To Include (data)', 'shelves_all_placements' ]] assert_frame_equal(expected_result.sort_index(axis=1), bay_max_shelves.sort_index(axis=1), check_dtype=False, check_column_type=False, check_names=True) def test_get_scene_bay_max_shelves_retrieves_expected_df_in_case_of_several_bays( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) expected_result = pd.DataFrame([{ u'kpi_level_2_fk': 304, u'type': PEPSICOUKSceneToolBox.PLACEMENT_BY_SHELF_NUMBERS_TOP, u'No of Shelves in Fixture (per bay) (key)': 6, u'Shelves From Bottom To Include (data)': '6', u'shelves_all_placements': '6,4,5,2,3,1' }, { u'kpi_level_2_fk': 305, u'type': 'Placement by shelf numbers_Eye', u'No of Shelves in Fixture (per bay) (key)': 6, u'Shelves From Bottom To Include (data)': '4,5', u'shelves_all_placements': '6,4,5,2,3,1' }, { u'kpi_level_2_fk': 306, u'type': 'Placement by shelf numbers_Middle', u'No of Shelves in Fixture (per bay) (key)': 6, u'Shelves From Bottom To Include (data)': '2,3', u'shelves_all_placements': '6,4,5,2,3,1' }, { u'kpi_level_2_fk': 307, u'type': 'Placement by shelf numbers_Bottom', u'No of Shelves in Fixture (per bay) (key)': 6, u'Shelves From Bottom To Include (data)': '1', u'shelves_all_placements': '6,4,5,2,3,1' }, { u'kpi_level_2_fk': 304, u'type': PEPSICOUKSceneToolBox.PLACEMENT_BY_SHELF_NUMBERS_TOP, u'No of Shelves in Fixture (per bay) (key)': 3, u'Shelves From Bottom To Include (data)': '3', u'shelves_all_placements': '3,2,1' }, { u'kpi_level_2_fk': 305, u'type': 'Placement by shelf numbers_Eye', u'No of Shelves in Fixture (per bay) (key)': 3, u'Shelves From Bottom To Include (data)': '2', u'shelves_all_placements': '3,2,1' }, { u'kpi_level_2_fk': 307, u'type': 'Placement by shelf numbers_Bottom', u'No of Shelves in Fixture (per bay) (key)': 3, u'Shelves From Bottom To Include (data)': '1', u'shelves_all_placements': '3,2,1' }]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) external_targets = scene_tb.commontools.all_targets_unpacked shelf_placmnt_targets = external_targets[ external_targets['operation_type'] == scene_tb.SHELF_PLACEMENT] if not shelf_placmnt_targets.empty: bay_max_shelves = scene_tb.get_scene_bay_max_shelves( shelf_placmnt_targets) bay_max_shelves = bay_max_shelves[[ 'kpi_level_2_fk', 'type', 'No of Shelves in Fixture (per bay) (key)', 'Shelves From Bottom To Include (data)', 'shelves_all_placements' ]] assert_frame_equal(expected_result.sort_index(axis=1), bay_max_shelves.sort_index(axis=1), check_dtype=False, check_column_type=False, check_names=True) def test_get_scene_bay_max_shelves_retrieves_empty_df_in_case_of_excluded_shelves( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 3) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) external_targets = scene_tb.commontools.all_targets_unpacked shelf_placmnt_targets = external_targets[ external_targets['operation_type'] == scene_tb.SHELF_PLACEMENT] if not shelf_placmnt_targets.empty: bay_max_shelves = scene_tb.get_scene_bay_max_shelves( shelf_placmnt_targets) self.assertTrue(bay_max_shelves.empty) def test_calculate_horizontal_placement(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 2) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) expected_list = [] expected_list.append({ 'kpi_fk': 304, 'numerator': 1, 'result': 5.0 / 5 * 100 }) expected_list.append({ 'kpi_fk': 307, 'numerator': 2, 'result': round(2.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 306, 'numerator': 2, 'result': round(2.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 305, 'numerator': 2, 'result': round(2.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 307, 'numerator': 3, 'result': 1.0 * 100 / 1 }) scene_tb.calculate_shelf_placement_horizontal() kpi_results = scene_tb.kpi_results kpi_results['result'] = kpi_results['result'].apply( lambda x: round(x, 5)) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) def test_calculate_horizontal_placement_does_not_calculate_kpis_if_irrelevant_scene( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 3) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_shelf_placement_horizontal() self.assertTrue(scene_tb.kpi_results.empty) def test_calculate_shelf_placement_vertical_mm_correcly_places_products_if_no_excluded_matches( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 2) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_shelf_placement_vertical_mm() expected_list = [] expected_list.append({ 'kpi_fk': 327, 'numerator': 1, 'result': 1.0 / 5 * 100 }) expected_list.append({ 'kpi_fk': 326, 'numerator': 1, 'result': 2.0 / 5 * 100 }) expected_list.append({ 'kpi_fk': 325, 'numerator': 1, 'result': 2.0 / 5 * 100 }) expected_list.append({ 'kpi_fk': 325, 'numerator': 2, 'result': 6.0 / 6 * 100 }) expected_list.append({ 'kpi_fk': 326, 'numerator': 3, 'result': 1.0 / 1 * 100 }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) def test_calculate_shelf_placement_vertical_mm_does_not_calculate_kpis_if_all_matches_excluded( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 3) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_shelf_placement_vertical_mm() self.assertTrue(scene_tb.kpi_results.empty) def test_calculate_shelf_placement_vertical_mm_in_case_excluded_matches_exist_and_different_stitch_groups( self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_shelf_placement_vertical_mm() kpi_results = scene_tb.kpi_results kpi_results['result'] = kpi_results['result'].apply( lambda x: round(x, 5)) expected_list = [] expected_list.append({ 'kpi_fk': 327, 'numerator': 4, 'result': round(1.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 326, 'numerator': 4, 'result': round(2.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 325, 'numerator': 4, 'result': round(3.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 325, 'numerator': 1, 'result': round(5.0 / 7 * 100, 5) }) expected_list.append({ 'kpi_fk': 326, 'numerator': 1, 'result': round(2.0 / 7 * 100, 5) }) expected_list.append({ 'kpi_fk': 325, 'numerator': 2, 'result': round(4.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 326, 'numerator': 2, 'result': round(2.0 / 6 * 100, 5) }) expected_list.append({ 'kpi_fk': 325, 'numerator': 3, 'result': round(4.0 / 8 * 100, 5) }) expected_list.append({ 'kpi_fk': 326, 'numerator': 3, 'result': round(3.0 / 8 * 100, 5) }) expected_list.append({ 'kpi_fk': 327, 'numerator': 3, 'result': round(1.0 / 8 * 100, 5) }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) non_expected_results = [] non_expected_results.append({'kpi_fk': 325, 'numerator': 0}) non_expected_results.append({'kpi_fk': 326, 'numerator': 0}) non_expected_results.append({'kpi_fk': 327, 'numerator': 0}) test_result_list = [] for result in non_expected_results: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, result) == 0) self.assertTrue(all(test_result_list)) def check_kpi_results(self, kpi_results_df, expected_results_dict): column = [] expression = [] condition = [] for key, value in expected_results_dict.items(): column.append(key) expression.append('==') condition.append(value) query = ' & '.join('{} {} {}'.format(i, j, k) for i, j, k in zip(column, expression, condition)) filtered_df = kpi_results_df.query(query) return len(filtered_df) def test_get_group_pairs_3_pass(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_combinations_3_pass_all pairs = scene_tb.get_group_pairs() self.assertEquals(len(pairs), 3) expected_result = [ frozenset(['Group 3', 'Group 1']), frozenset(['Group 2', 'Group 1']), frozenset(['Group 2', 'Group 3']) ] self.assertItemsEqual(pairs, expected_result) def test_get_group_pairs_2_pass_out_of_3(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_combinations_2_pass_of_3 pairs = scene_tb.get_group_pairs() expected_result = [frozenset(['Group 2', 'Group 1'])] self.assertEquals(len(pairs), 1) self.assertItemsEqual(pairs, expected_result) def test_get_group_pairs_1_pass_out_of_3(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_combinations_1_pass_of_3 pairs = scene_tb.get_group_pairs() self.assertEquals(len(pairs), 0) def test_get_group_pairs_4_pass_out_of_4(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) self.mock_object('PositionGraphs', path='KPIUtils_v2.Calculations.AdjacencyCalculations') scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_combinations_4_pass_of_4 pairs = scene_tb.get_group_pairs() expected = [ frozenset(['Group 3', 'Group 1']), frozenset(['Group 4', 'Group 2']), frozenset(['Group 4', 'Group 3']), frozenset(['Group 2', 'Group 3']), frozenset(['Group 4', 'Group 1']), frozenset(['Group 2', 'Group 1']) ] self.assertEquals(len(pairs), 6) self.assertItemsEqual(pairs, expected) def test_block_together_blocks_fail(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) self.mock_block_results([ DataTestUnitPEPSICOUK.block_results_empty, DataTestUnitPEPSICOUK.block_results_failed ]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_product_blocking_new() kpi_result = scene_tb.kpi_results self.assertEquals(len(kpi_result), 2) expected_list = list() expected_list.append({ 'kpi_fk': 319, 'numerator': 165, 'result': 5, 'score': 0 }) expected_list.append({ 'kpi_fk': 319, 'numerator': 166, 'result': 5, 'score': 0 }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(kpi_result, expected_result) == 1) self.assertTrue(all(test_result_list)) expected_util_result = list() expected_util_result.append({ 'Group Name': 'Pringles_FTT_Tubes', 'Score': 0 }) expected_util_result.append({ 'Group Name': 'Hula Hoops_LMP_Snacks', 'Score': 0 }) test_result_list = list() for exp_res in expected_util_result: test_result_list.append( len(scene_tb.block_results[ (scene_tb.block_results['Group Name'] == exp_res['Group Name']) & (scene_tb.block_results['Score'] == exp_res['Score'])]) == 1) self.assertTrue(all(test_result_list)) self.assertFalse(scene_tb.passed_blocks) def test_block_together_vertical_and_horizontal(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) self.mock_block_results([ DataTestUnitPEPSICOUK.block_results, DataTestUnitPEPSICOUK.block_results_2 ]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_product_blocking_new() kpi_result = pd.DataFrame(scene_tb.kpi_results) self.assertEquals(len(kpi_result), 2) expected_list = list() expected_list.append({ 'kpi_fk': 319, 'numerator': 165, 'result': 4, 'score': 7 }) expected_list.append({ 'kpi_fk': 319, 'numerator': 166, 'result': 4, 'score': 6 }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(kpi_result, expected_result) == 1) self.assertTrue(all(test_result_list)) expected_util_result = list() expected_util_result.append({ 'Group Name': 'Pringles_FTT_Tubes', 'Score': 1 }) expected_util_result.append({ 'Group Name': 'Hula Hoops_LMP_Snacks', 'Score': 1 }) test_result_list = list() for exp_res in expected_util_result: test_result_list.append( len(scene_tb.block_results[ (scene_tb.block_results['Group Name'] == exp_res['Group Name']) & (scene_tb.block_results['Score'] == exp_res['Score'])]) == 1) self.assertTrue(all(test_result_list)) self.assertItemsEqual(scene_tb.passed_blocks.keys(), ['Pringles_FTT_Tubes', 'Hula Hoops_LMP_Snacks']) def test_adjacency_no_results_if_one_block_passes(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_one_passes scene_tb.calculate_adjacency_new() self.assertTrue(scene_tb.kpi_results.empty) def test_adjacency_no_results_if_no_blocks_pass(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_none_passes scene_tb.calculate_adjacency_new() self.assertTrue(scene_tb.kpi_results.empty) def test_adjacency_fails(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) self.mock_adjacency_results( [DataTestUnitPEPSICOUK.adjacency_results_false]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.passed_blocks = { 'Pringles_FTT_Tubes': DataTestUnitPEPSICOUK.block_results, 'Hula Hoops_LMP_Snacks': DataTestUnitPEPSICOUK.block_results_2 } scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_all_pass scene_tb.calculate_adjacency_new() kpi_result = scene_tb.kpi_results self.assertEquals(len(kpi_result), 1) expected_list = list() expected_list.append({ 'kpi_fk': 320, 'numerator': 166, 'denominator': 165, 'result': 5, 'score': 0 }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(kpi_result, expected_result) == 1) self.assertTrue(all(test_result_list)) def test_adjacency_passes(self): probe_group, matches, scif = self.create_scene_scif_matches_stitch_groups_data_mocks( DataTestUnitPEPSICOUK.test_case_1, 1) self.mock_adjacency_results( [DataTestUnitPEPSICOUK.adjacency_results_true]) scene_tb = PEPSICOUKSceneToolBox(self.data_provider_mock, self.output) scene_tb.passed_blocks = { 'Pringles_FTT_Tubes': DataTestUnitPEPSICOUK.block_results, 'Hula Hoops_LMP_Snacks': DataTestUnitPEPSICOUK.block_results_2 } scene_tb.block_results = DataTestUnitPEPSICOUK.blocks_all_pass scene_tb.calculate_adjacency_new() kpi_result = scene_tb.kpi_results self.assertEquals(len(kpi_result), 1) expected_list = list() expected_list.append({ 'kpi_fk': 320, 'numerator': 166, 'denominator': 165, 'result': 4, 'score': 1 }) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(kpi_result, expected_result) == 1) self.assertTrue(all(test_result_list))
class TestMarsuaeSandScene(TestFunctionalCase): seeder = Seeder() @property def import_path(self): return 'Projects.MARSUAE_SAND.Utils.KPISceneToolBox' def set_up(self): super(TestMarsuaeSandScene, self).set_up() self.mock_data_provider() self.data_provider_mock.project_name = 'Test_Project_1' self.data_provider_mock.rds_conn = MagicMock() self.db_users_mock = self.mock_db_users() self.project_connector_mock = self.mock_project_connector() self.mock_common_project_connector_mock = self.mock_common_project_connector( ) self.static_kpi_mock = self.mock_static_kpi() self.session_info_mock = self.mock_session_info() self.output = MagicMock() self.session_info_mock = self.mock_session_info() self.mock_all_products() def mock_probe_group(self, data): probe_group = self.mock_object('PEPSICOUKSceneToolBox.get_probe_group') probe_group.return_value = data.where(data.notnull(), None) return probe_group.return_value def mock_data_provider(self): self.data_provider_mock = MagicMock() # return self._data_provider self.data_provider_data_mock = {} def get_item(key): return self.data_provider_data_mock[ key] if key in self.data_provider_data_mock else MagicMock() self.data_provider_mock.__getitem__.side_effect = get_item def mock_db_users(self): return self.mock_object( 'DbUsers', path='KPIUtils_v2.DB.CommonV2'), self.mock_object('DbUsers') def mock_project_connector(self): return self.mock_object('PSProjectConnector') def mock_common_project_connector(self): return self.mock_object('PSProjectConnector', path='KPIUtils_v2.DB.CommonV2') def mock_session_info(self): return self.mock_object('SessionInfo', path='Trax.Algo.Calculations.Core.Shortcuts') def mock_static_kpi(self): static_kpi = self.mock_object('Common.get_kpi_static_data', path='KPIUtils_v2.DB.CommonV2') static_kpi.return_value = DataTestUnitMarsuae.kpi_static_data return static_kpi.return_value def mock_all_products(self): self.data_provider_mock[ 'all_products'] = DataTestUnitMarsuae.all_products_scene def mock_match_product_in_scene(self, data): self.data_provider_data_mock['matches'] = data.where( data.notnull(), None) def mock_scene_item_facts(self, data): self.data_provider_data_mock['scene_item_facts'] = data.where( data.notnull(), None) def test_calculate_price_generates_no_kpi_results_if_no_prices_in_scene( self): self.mock_match_product_in_scene(DataTestUnitMarsuae.scene_1_no_prices) self.mock_scene_item_facts(DataTestUnitMarsuae.scene_1_scif) scene_tb = MARSUAE_SANDSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_price() self.assertTrue(scene_tb.kpi_results.empty) def test_calculate_price_returns_max_result_and_only_for_products_with_prices( self): self.mock_match_product_in_scene(DataTestUnitMarsuae.scene_2) self.mock_scene_item_facts(DataTestUnitMarsuae.scene_2_scif) scene_tb = MARSUAE_SANDSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_price() expected_list = list() expected_list.append({'kpi_fk': 3004, 'numerator': 1, 'result': 4.5}) expected_list.append({'kpi_fk': 3004, 'numerator': 3, 'result': 2}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) self.assertEquals(len(scene_tb.kpi_results), 2) def test_calculate_price_returns_max_result_among_price_and_promo_price( self): self.mock_match_product_in_scene(DataTestUnitMarsuae.scene_3) self.mock_scene_item_facts(DataTestUnitMarsuae.scene_3_scif) scene_tb = MARSUAE_SANDSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_price() expected_list = list() expected_list.append({'kpi_fk': 3004, 'numerator': 1, 'result': 5}) expected_list.append({'kpi_fk': 3004, 'numerator': 3, 'result': 2}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) self.assertEquals(len(scene_tb.kpi_results), 2) def test_calculate_price_returns_prices_only_for_sku_products(self): self.mock_match_product_in_scene( DataTestUnitMarsuae.scene_4_with_non_mars) self.mock_scene_item_facts(DataTestUnitMarsuae.scene_4_scif) scene_tb = MARSUAE_SANDSceneToolBox(self.data_provider_mock, self.output) scene_tb.own_manufacturer_fk = 3 scene_tb.calculate_price() expected_list = list() expected_list.append({'kpi_fk': 3004, 'numerator': 1, 'result': 5}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) self.assertEquals(len(scene_tb.kpi_results), 1) def test_calculate_price_returns_max_result_among_price_and_promo_price_if_one_of_them_is_none( self): self.mock_match_product_in_scene(DataTestUnitMarsuae.scene_5) self.mock_scene_item_facts(DataTestUnitMarsuae.scene_5_scif) scene_tb = MARSUAE_SANDSceneToolBox(self.data_provider_mock, self.output) scene_tb.calculate_price() expected_list = list() expected_list.append({'kpi_fk': 3004, 'numerator': 1, 'result': 4}) expected_list.append({'kpi_fk': 3004, 'numerator': 2, 'result': 5}) test_result_list = [] for expected_result in expected_list: test_result_list.append( self.check_kpi_results(scene_tb.kpi_results, expected_result) == 1) self.assertTrue(all(test_result_list)) self.assertEquals(len(scene_tb.kpi_results), 2) @staticmethod def check_kpi_results(kpi_results_df, expected_results_dict): column = [] expression = [] condition = [] for key, value in expected_results_dict.items(): column.append(key) expression.append('==') condition.append(value) query = ' & '.join('{} {} {}'.format(i, j, k) for i, j, k in zip(column, expression, condition)) filtered_df = kpi_results_df.query(query) return len(filtered_df)
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() self.mock_object(object_name='commit_results_data', path='KPIUtils_v2.DB.CommonV2.Common') @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_old_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_new_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_level_2_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_scene_tables_kpi_results_filled(self): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.scene_kpi_results ''') kpi_results = cursor.fetchall() self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["marsin_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_marsin_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = {'fe86a2e5-6259-4d69-a6ae-4d427e2bce81': []} for session in sessions.keys(): data_provider.load_session_data(str(session)) output = Output() MARSINCalculations(data_provider, output).run_project_calculations()
class TestPngjpSanityPerKPI(TestFunctionalCase): seeder = Seeder() def set_up(self): super(TestPngjpSanityPerKPI, self).set_up() # mock parse_template to return the expected DFs self.get_template_path_mock = MagicMock( 'parse_template', path='Projects.PNGJP.Utils.ParseTemplates', side_effect=[ pd.DataFrame(parse_template_data.template_data), pd.DataFrame(parse_template_data.innovation_assortment), pd.DataFrame(parse_template_data.psku_assortment), pd.DataFrame(parse_template_data.scene_types), pd.DataFrame(parse_template_data.golden_zone_data_criteria) ]) # get expected results data self.test_results_against = pd.DataFrame( expected_results_from_db.expected_results) self.kpi_expected_results_df = self.test_results_against[ ~self.test_results_against['sum_result'].isnull()] # load seed data self.save_kpi_results_in_seed() # get actual results from seed self.kpi_actual_results_df = self.get_kpi_actual_results_from_seed() # mock template remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') @staticmethod @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def save_kpi_results_in_seed(): """ load the session and save the results in the seed results for the KPIs """ project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) session = 'E14412B2-BEF5-4380-B5D0-D3E23674C32B' data_provider.load_session_data(session) @staticmethod @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def get_kpi_actual_results_from_seed(): """get results from seed""" connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute('''SELECT * FROM report.kpi_results''') temp = cursor.fetchall() # save results to df df = pd.DataFrame(list(temp), columns=[col[0] for col in cursor.description]) # filter unneeded columns df_filtered = df[['kps_name', 'kpi_fk', 'result']] # copy kpi_fk in-order to count the fks df_filtered['kpi_fk_count'] = df['kpi_fk'] # convert string result to float df_filtered['result'] = pd.to_numeric(df_filtered['result']) # sum results and count fks df_calculated = df_filtered.groupby('kpi_fk').agg({ 'kpi_fk_count': 'count', 'result': 'sum' }).reset_index().rename(columns={'result': 'results sum'}) df_calculated = df_calculated[~(df_calculated['results sum'] == 0.0)] return df_calculated @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_SKU_Distribution_Raw_Data(self): kpi_name = 'SKU Distribution Raw Data' kpi_fk = 1 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_SKU_Distribution_Primary(self): kpi_name = 'SKU Distribution (Primary)' kpi_fk = 2 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_SKU_OOS_Primary(self): kpi_name = 'SKU OOS (Primary)' kpi_fk = 3 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Linear_Shelf_Space_by_Manufacturer(self): kpi_name = 'Linear Shelf Space (by Manufacturer)' kpi_fk = 6 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Linear_Shelf_Space_Primary(self): kpi_name = 'Linear Shelf Space (Primary)' kpi_fk = 7 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Facings_Primary_by_Manufacturer(self): kpi_name = 'Number of Facings (Primary) (by Manufacturer)' kpi_fk = 10 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Facings_Primary(self): kpi_name = 'Number of Facings (Primary)' kpi_fk = 11 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Facings_Primary_Raw_Data(self): kpi_name = 'Number of Facings (Primary) Raw Data' kpi_fk = 12 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Share_of_Shelf_Facings_by_Empty_Space(self): kpi_name = 'Share of Shelf Facings by Empty Space' kpi_fk = 13 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Golden_Zone_Compliance(self): kpi_name = 'Golden Zone Compliance' kpi_fk = 14 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Display_Raw_Data(self): kpi_name = 'Display Raw Data' kpi_fk = 16 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Display_by_Brand(self): kpi_name = 'Number of Display (by Brand)' kpi_fk = 17 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Size_of_Display_Raw_Data(self): kpi_name = 'Size of Display Raw Data' kpi_fk = 21 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Size_of_Display_by_Manufacturer(self): kpi_name = 'Size of Display (by Manufacturer)' kpi_fk = 22 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Facings_by_Brand(self): kpi_name = 'Number of Facings (by Brand)' kpi_fk = 23 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_SKU_on_Display_Raw_Data(self): kpi_name = 'SKU on Display Raw Data' kpi_fk = 24 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_SKU_on_Display_by_Category(self): kpi_name = 'SKU on Display (by Category)' kpi_fk = 25 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_PSKU_Distribution_Raw_Data(self): kpi_name = 'PSKU Distribution Raw Data' kpi_fk = 27 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_PSKU_Presence(self): kpi_name = 'PSKU Presence' kpi_fk = 28 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Number_of_Display_by_Category(self): kpi_name = 'Number of Display (by Category)' kpi_fk = 68 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency124(self): kpi_name = 'Adjacency124' kpi_fk = 124 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency125(self): kpi_name = 'Adjacency125' kpi_fk = 125 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency126(self): kpi_name = 'Adjacency126' kpi_fk = 126 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency127(self): kpi_name = 'Adjacency127' kpi_fk = 127 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency128(self): kpi_name = 'Adjacency128' kpi_fk = 128 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency129(self): kpi_name = 'Adjacency129' kpi_fk = 129 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency130(self): kpi_name = 'Adjacency130' kpi_fk = 130 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = \ self.kpi_actual_results_df[self.kpi_actual_results_df['kpi_fk'] == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name)) @seeder.seed(["mongodb_products_and_brands_seed", "pngjp_seed"], ProjectsSanityData()) def test_Adjacency131(self): kpi_name = 'Adjacency131' kpi_fk = 131 expected_result = \ self.kpi_expected_results_df[self.kpi_expected_results_df.kpi_fk == kpi_fk]['sum_result'].values[0] actual_result = self.kpi_actual_results_df[ self.kpi_actual_results_df.kpi_fk == kpi_fk]['results sum'].values[0] self.assertAlmostEqual( expected_result, actual_result, msg='KPI {} results are not as expected'.format(kpi_name))
class TestKEngineOutOfTheBox(TestFunctionalCase): def set_up(self): super(TestKEngineOutOfTheBox, self).set_up() remove_cache_and_storage() @property def import_path(self): return 'Trax.Apps.Services.KEngine.Handlers.SessionHandler' @property def config_file_path(self): return os.path.join(os.path.dirname(os.path.realpath(__file__)), 'k-engine-test.config') seeder = Seeder() def _assert_old_tables_kpi_results_filled(self, distinct_kpis_num=None): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.kpi_results ''') kpi_results = cursor.fetchall() if distinct_kpis_num: df = pd.DataFrame(kpi_results) self.assertEquals(df['kpi_level_2_fk'].unique().__len__(), distinct_kpis_num) else: self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() def _assert_new_tables_kpi_results_filled(self, distinct_kpis_num=None, list_of_kpi_names=None): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT kl2.pk, kl2.client_name, kl2r.kpi_level_2_fk, kl2r.result FROM report.kpi_level_2_results kl2r left join static.kpi_level_2 kl2 on kpi_level_2_fk = kl2.pk ''') kpi_results = cursor.fetchall() df = pd.DataFrame(kpi_results) if distinct_kpis_num: self.assertEquals(df['kpi_level_2_fk'].unique().__len__(), distinct_kpis_num) else: self.assertNotEquals(len(kpi_results), 0) if list_of_kpi_names: exisitng_results = df['client_name'].unique() result = all(elem in exisitng_results for elem in list_of_kpi_names) self.assertTrue(result) connector.disconnect_rds() def _assert_scene_tables_kpi_results_filled(self, distinct_kpis_num=None): connector = PSProjectConnector(TestProjectsNames().TEST_PROJECT_1, DbUsers.Docker) cursor = connector.db.cursor() cursor.execute(''' SELECT * FROM report.scene_kpi_results ''') kpi_results = cursor.fetchall() if distinct_kpis_num: df = pd.DataFrame(kpi_results) self.assertEquals(df['kpi_level_2_fk'].unique().__len__(), distinct_kpis_num) else: self.assertNotEquals(len(kpi_results), 0) connector.disconnect_rds() @seeder.seed(["cckr_seed", "mongodb_products_and_brands_seed"], ProjectsSanityData()) def test_cckr_sanity(self): project_name = ProjectsSanityData.project_name data_provider = KEngineDataProvider(project_name) sessions = {'895a4d8f-3523-4131-94f9-ac2ac364ddd9': []} for session in sessions.keys(): data_provider.load_session_data(str(session)) output = Output() Calculations(data_provider, output).run_project_calculations()