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()
