def test_correct_num_points_for_10pt_curves(self, mock_input1,
                                                mock_input2):

        df_result = spr_setup_sheet()
        df_result = df_result[df_result['BRD'] == 'BRD-6261_1']

        self.assertEqual(12, len(df_result))
    def test_correct_BRD_format(self, mock_input1, mock_input2):
        """
        Test that confirms that the length of the BRD's are truncated to 10 characters.
        """

        df_result = spr_setup_sheet()
        self.assertEqual(10, len(str(df_result.iloc[1]['BRD'])))
    def test_spr_setup_sheet_method_input(self, mock_input1, mock_input2):
        """
        Test that confirms that the a DataFrame is returned from spr setup sheet method.
        """

        result = spr_setup_sheet()
        self.assertEqual(result.__class__, pd.DataFrame)
    def test_correct_order_and_calc_off_concentrations(self, mock_input1,
                                                       mock_input2):
        """
        Using the test setup tbl verify that the correct concentrations are calculated and sorted given different
        starting concentrations.
        """

        ls_corr = [
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0390625, 0.0390625, 0.0390625,
            0.0390625, 0.0390625, 0.0390625, 0.0390625, 0.0390625, 0.0390625,
            0.078125, 0.078125, 0.078125, 0.078125, 0.078125, 0.078125,
            0.078125, 0.078125, 0.078125, 0.09765625, 0.09765625, 0.15625,
            0.15625, 0.15625, 0.15625, 0.15625, 0.15625, 0.15625, 0.15625,
            0.15625, 0.1953125, 0.1953125, 0.1953125, 0.1953125, 0.1953125,
            0.1953125, 0.1953125, 0.3125, 0.3125, 0.3125, 0.3125, 0.3125,
            0.3125, 0.3125, 0.3125, 0.3125, 0.390625, 0.390625, 0.390625,
            0.390625, 0.390625, 0.390625, 0.390625, 0.625, 0.625, 0.625, 0.625,
            0.625, 0.625, 0.625, 0.625, 0.625, 0.78125, 0.78125, 0.78125,
            0.78125, 0.78125, 0.78125, 0.78125, 1.25, 1.25, 1.25, 1.25, 1.25,
            1.25, 1.25, 1.25, 1.25, 1.5625, 1.5625, 1.5625, 1.5625, 1.5625,
            1.5625, 1.5625, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 3.125,
            3.125, 3.125, 3.125, 3.125, 3.125, 3.125, 5.0, 5.0, 5.0, 5.0, 5.0,
            5.0, 5.0, 5.0, 5.0, 6.25, 6.25, 6.25, 6.25, 6.25, 6.25, 6.25, 10.0,
            10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 12.5, 12.5, 12.5,
            12.5, 12.5, 12.5, 12.5, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0,
            20.0, 20.0, 25.0, 25.0, 25.0, 25.0, 25.0, 25.0, 25.0, 50.0, 50.0,
            50.0, 50.0, 50.0, 50.0, 50.0, 100.0, 100.0, 100.0, 100.0, 100.0
        ]

        df_result = spr_setup_sheet()
        df_result = df_result.loc[:, 'CONC']

        self.assertEqual(ls_corr, list(df_result))
    def test_correct_column_headers(self, monkeypatch, mock_input2):
        """

        :return:
        """
        expected_headers = ['BRD', 'MW', 'CONC', 'BAR']
        df_result = spr_setup_sheet()
        self.assertEqual(expected_headers, list(df_result.columns))
    def test_correct_3_fold_dilution_6_pts(self, mock_input1, mock_input2):

        ls_corr = [
            0.0, 0.0, 0.20576131687242802, 0.617283950617284,
            1.851851851851852, 5.555555555555556, 16.666666666666668, 50.0
        ]

        df_result = spr_setup_sheet()
        df_result = df_result[df_result['BRD'] == 'BRD-4351_3']
        con_series = list(df_result.loc[:, 'CONC'])
        self.assertEqual(ls_corr, con_series)
    def test_correct_two_fold_dilution_10_pts(self, mock_input1, mock_input2):

        ls_corr = [
            0, 0, 0.09765625, 0.1953125, 0.390625, 0.78125, 1.5625, 3.125,
            6.25, 12.5, 25, 50
        ]

        df_result = spr_setup_sheet()
        df_result = df_result[df_result['BRD'] == 'BRD-6261_1']
        con_series = list(df_result.loc[:, 'CONC'])
        self.assertEqual(ls_corr, con_series)
    def test_two_zero_conc_points_first_cmpd(self, mock_input1, mock_input2):
        """
        Test to verify that the first to concentration points are zero
        """

        df_result = spr_setup_sheet()

        zero_one = df_result.iloc[1]['CONC']
        zero_two = df_result.iloc[1]['CONC']
        self.assertEqual(0, zero_one)
        self.assertEqual(0, zero_two)
    def test_correct_1pt5_fold_dilution_8_pts(self, mock_input1, mock_input2):

        ls_corr = [
            0.0, 0.0, 2.9263831732967542, 4.389574759945131, 6.584362139917697,
            9.876543209876544, 14.814814814814817, 22.222222222222225,
            33.333333333333336, 50.0
        ]

        df_result = spr_setup_sheet()
        df_result = df_result[df_result['BRD'] == 'BRD-4350_2']
        con_series = list(df_result.loc[:, 'CONC'])
        self.assertEqual(ls_corr, con_series)
    def test_correct_output_barcodes(self, mock_input1, mock_input2):
        """
        Test to verify that the barcodes for the output file are in the correct order.
        """

        ls_corr = [
            1172907815, 1196291078, 1196291070, 1196293322, 1196293323,
            1196293331, 1196293339, 1196293347, 1196293324, 1196291038,
            1172907815, 1196291030, 1196291046, 1196291062, 1196291022,
            1196291054, 1172907815, 1196291078, 1196291070, 1196293322,
            1196293323, 1196293331, 1196293339, 1196293347, 1196293324,
            1196291038, 1172907815, 1196291030, 1196291046, 1196291062,
            1196291022, 1196291054, 1196291078, 1196291070, 1196293322,
            1196293323, 1196293331, 1196293339, 1196293347, 1196293324,
            1196291038, 1196291078, 1196291070, 1196293322, 1196293323,
            1196293331, 1196293339, 1196293347, 1196293324, 1196291038,
            1172907815, 1172907815, 1196291078, 1196291070, 1196293322,
            1196293323, 1196293331, 1196293339, 1196293347, 1196293324,
            1196291038, 1172907815, 1172907815, 1196291030, 1196291046,
            1196291062, 1196291022, 1196291054, 1196291078, 1196291070,
            1196293322, 1196293323, 1196293331, 1196293339, 1196293347,
            1196293324, 1196291038, 1172907815, 1172907815, 1196291030,
            1196291046, 1196291062, 1196291022, 1196291054, 1196291078,
            1196291070, 1196293322, 1196293323, 1196293331, 1196293339,
            1196293347, 1196293324, 1196291038, 1172907815, 1172907815,
            1196291030, 1196291046, 1196291062, 1196291022, 1196291054,
            1196291078, 1196291070, 1196293322, 1196293323, 1196293331,
            1196293339, 1196293347, 1196293324, 1196291038, 1172907815,
            1172907815, 1196291030, 1196291046, 1196291062, 1196291022,
            1196291054, 1196291078, 1196291070, 1196293322, 1196293323,
            1196293331, 1196293339, 1196293347, 1196293324, 1196291038,
            1172907815, 1172907815, 1196291030, 1196291046, 1196291062,
            1196291022, 1196291054, 1196291078, 1196291070, 1196293322,
            1196293323, 1196293331, 1196293339, 1196293347, 1196293324,
            1196291038, 1172907815, 1172907815, 1196291030, 1196291046,
            1196291062, 1196291022, 1196291054, 1196291078, 1196291070,
            1196293322, 1196293323, 1196293331, 1196293339, 1196293347,
            1196293324, 1196291038, 1172907815, 1172907815, 1196291030,
            1196291046, 1196291062, 1196291022, 1196291054, 1196291078,
            1196291070, 1196293322, 1196293323, 1196293331, 1196293339,
            1196293347, 1196293324, 1196291038, 1172907815, 1172907815,
            1196291030, 1196291046, 1196291062, 1196291022, 1196291054,
            1172907815, 1172907815, 1196291030, 1196291046, 1196291062,
            1196291022, 1196291054, 1196291030, 1196291046, 1196291062,
            1196291022, 1196291054
        ]

        df_result = spr_setup_sheet()
        df_result = df_result.loc[:, 'BAR']

        self.assertEqual(ls_corr, list(df_result))
    def test_correct_cmpd_order(self, mock_input1, mock_input2):
        """
        Test to verify that the compounds have been sorted correctly
        """

        ls_corr = [
            'BRD-6261_1', 'BRD-4350_2', 'BRD-4351_3', 'BRD-4580_4',
            'BRD-4582_5', 'BRD-4581_6', 'BRD-4583_7', 'BRD-4585_8',
            'BRD-4584_9', 'BRD-4344_10', 'BRD-6261_11', 'BRD-4340_12',
            'BRD-4341_13', 'BRD-4349_14', 'BRD-4348_15', 'BRD-4345_16'
        ]

        df_result = spr_setup_sheet()
        self.assertEqual(ls_corr, list(df_result.iloc[0:16]['BRD']))
from script_spr_setup_file.Create_SPR_setup_file import spr_setup_sheet

if __name__ == '__main__':
    spr_setup_sheet()