Beispiel #1
0
    def test_index_comparison_with_utility_function(self):

        self.logTestTile("Test su ogni anagrafica importata")

        dp = self.data_dp.copy()
        db = self.data_db.copy()

        # Creo una colonna fittizia per il confronto
        db['col1'] = "presente"

        names = self.db_keys
        dp.index.set_names(names, inplace=True)
        db.index.set_names(names, inplace=True)
        df_check = dataframe_index_differences(dp, db, how='left')

        # LOG if there is some missing
        if ~df_check.empty:
            df_check.reset_index().index.set_names("Indice", inplace=True)
            message = f"Nella tabella ci sono {df_check.shape[0]} righe non importate.\n"
            self.logDataFrame(df=df_check, message=message)

        self.assertTrue(
            df_check.empty,
            f"Inner join left tra i due df ha {df_check.shape[0]} valori mancanti"
        )
Beispiel #2
0
    def test_index_comparison_with_utility_function(self):
        
        self.logTestTile("Test su ogni certificazione importata con funzione Utility")

        custom_dp_df = self.data_dp.copy()
        custom_db_df = self.data_db.iloc[:, [1, 2, 3, 9]].copy()

        # CF, PV e CodiceCertificazione sono univoci
        custom_dp_df.set_index(
            ['CF', "PV", "CodiceCertificazione"], inplace = True)
        custom_db_df.set_index(
            ["CF", "ID_Provincia", "CodiceCertificazione"], inplace = True
        )

        df_check = dataframe_index_differences(
            custom_dp_df,
            custom_db_df,
            how='left'
        )

        # LOG if there is some missing
        if ~ df_check.empty:
            df_check.reset_index().index.set_names("Indice", inplace=True)
            message = f"Nella tabella ci sono {df_check.shape[0]} certificazioni non importate.\n" + \
                "Nella colonna DataCertificazione e' indicato con ```True``` che la " + \
                "certificazione e' mancante."
            self.logDataFrame(df=df_check, message=message)

        self.assertTrue(
            df_check.empty,
            f"Inner join left tra i due df ha {df_check.shape[0]} valori mancanti"
        )
Beispiel #3
0
    def test_dataframe_index_differences_defaultIndex(self):
        data = {
            'col1': ['a', 'b', 'c'],
            'col2': [1, 2, 3],
            'col3': [0.5, 0.04, 0.99]
        }

        df1 = pd.DataFrame(data)
        df2 = pd.DataFrame(data)
        df_check = dataframe_index_differences(df1, df2)
        self.assertTrue(
            df_check.empty,
            "Il DataFrame dev'essere vuoto perché i DataFrames comparati sono uguali"
        )
Beispiel #4
0
    def test_dataframe_index_differences_WrongNumericalIndex(self):
        data = {
            'col1': ['a', 'b', 'c'],
            'col2': [1, 2, 3],
            'col3': [0.5, 0.04, 0.99]
        }
        nums1 = [1, 2, 3]
        nums2 = [1, 5, 3]

        df1 = pd.DataFrame(data, index=nums1)
        df2 = pd.DataFrame(data, index=nums2)
        df_check = dataframe_index_differences(df1, df2)
        self.assertFalse(
            df_check.empty,
            "Il DataFrame dev'essere vuoto perché i DataFrames comparati sono uguali"
        )
Beispiel #5
0
    def test_dataframe_index_differences_WrongLabelIndex_rightJoin(self):
        data = {
            'col1': ['a', 'b', 'c'],
            'col2': [1, 2, 3],
            'col3': [0.5, 0.04, 0.99]
        }
        labels1 = ['a', 'b', 'c']
        labels2 = ['a', 'b', 'f']

        df1 = pd.DataFrame(data, index=labels1)
        df2 = pd.DataFrame(data, index=labels2)
        df_check = dataframe_index_differences(df1, df2, 'right')
        self.assertFalse(
            df_check.empty,
            "Il DataFrame dev'essere vuoto perché i DataFrames comparati sono uguali"
        )
Beispiel #6
0
    def test_dataframe_index_differences_multiIndex(self):
        data = {
            'col1': ['a', 'b', 'c'],
            'col2': [1, 2, 3],
            'col3': [0.5, 0.04, 0.99]
        }
        labels = [['a', 'b', 'c'], ['d', 'e', 'f']]

        tuples = list(zip(*labels))  # * means flatten array

        index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])

        df1 = pd.DataFrame(data, index=index)
        df2 = pd.DataFrame(data, index=index)
        df_check = dataframe_index_differences(df1, df2)
        self.assertTrue(
            df_check.empty,
            "Il DataFrame dev'essere vuoto perché i DataFrames comparati sono uguali"
        )
Beispiel #7
0
    def test_dataframe_index_differences_WrongMultiIndex_rightJoin(self):
        data = {
            'col1': ['a', 'b', 'c'],
            'col2': [1, 2, 3],
            'col3': [0.5, 0.04, 0.99]
        }
        labels1 = ['a', 'b', 'c']
        labels1_mod = ['a', 'b', 'f']
        labels2 = ['d', 'e', 'f']

        tuples1 = list(zip(labels1, labels2))
        tuples2 = list(zip(labels1_mod, labels2))

        index1 = pd.MultiIndex.from_tuples(tuples1, names=['first', 'second'])
        index2 = pd.MultiIndex.from_tuples(tuples2, names=['first', 'second'])

        df1 = pd.DataFrame(data, index=index1)
        df2 = pd.DataFrame(data, index=index2)
        df_check = dataframe_index_differences(df1, df2, 'right')
        self.assertFalse(
            df_check.empty,
            "Il DataFrame dev'essere vuoto perché i DataFrames comparati sono uguali"
        )