From c6e32af5beea60801874b6180f113e1d6fc6e677 Mon Sep 17 00:00:00 2001 From: Clgould99 Date: Mon, 3 Jun 2024 17:11:51 -0700 Subject: [PATCH] adding remaining unittest for etl and vis --- alfred/etl.py | 2 +- alfred/tests/test_etl.py | 257 +++++++++++++++++++++++++++++++++++---- alfred/tests/test_vis.py | 249 ++++++++++++++++++++++++++++++++++--- alfred/vis.py | 63 +--------- 4 files changed, 465 insertions(+), 106 deletions(-) diff --git a/alfred/etl.py b/alfred/etl.py index c99f0a1..e665221 100644 --- a/alfred/etl.py +++ b/alfred/etl.py @@ -141,7 +141,7 @@ def group_files(directory): count += 1 else: moved_files.append(filename) - incomplete = os.path.join(directory, 'incomplete_test') + incomplete = os.path.join(directory, 'incomplete') if not os.path.exists(incomplete): os.makedirs(incomplete) destination = os.path.join(incomplete, filename) diff --git a/alfred/tests/test_etl.py b/alfred/tests/test_etl.py index 2e4ae25..58a5f4a 100644 --- a/alfred/tests/test_etl.py +++ b/alfred/tests/test_etl.py @@ -3,6 +3,7 @@ import unittest import zipfile import pandas as pd +import numpy as np import shutil import alfred @@ -20,7 +21,7 @@ def setUp(self): zip_ref.extractall(self.temp_dir) def test_find_directory_ends_with_forward_slash(self): - directory = alfred.etl.find_directory() + directory = alfred.find_directory() self.assertTrue(directory.endswith('/'), "Directory does not end with a forward slash") def tearDown(self): @@ -50,7 +51,7 @@ def test_grab_csv(self): Testing the grab_csv function. """ # find the csvs extracted from the zip - result = alfred.etl.grab_csv(self.temp_dir) + result = alfred.grab_csv(self.temp_dir) expected_result = [ '14F0154_ProfileData_20171116125343(2).csv', '14B0059_ProfileData_20180403061303(2).csv', @@ -73,7 +74,7 @@ def test_grab_csv(self): self.assertListEqual(result, expected_result) # this should return an empty list - result = alfred.etl.grab_csv(data_path) + result = alfred.grab_csv(data_path) self.assertListEqual(result, []) def tearDown(self): @@ -86,36 +87,242 @@ def tearDown(self): os.remove(file_path) os.rmdir(self.temp_dir) -from alfred.etl import group_files + + class TestGroupFiles(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'unsorted_test_data') + + def test_group_file_creates_subdirectories(self): + alfred.group_files(self.valid_directory) + + # Define the expected subdirectory names + expected_subdirs = [ + "bus_0039141908140233500710", + "bus_0039142006m40233500710", + "bus_0039142903b40233500710", + "bus_0039151006940233500710", + "incomplete" + ] + for subdir_name in expected_subdirs: + subdir_path = os.path.join(self.valid_directory, subdir_name) + # Check if the subdirectory exists + self.assertTrue(os.path.exists(subdir_path)) + # Check if it's a directory + self.assertTrue(os.path.isdir(subdir_path)) + def test_bus_0039141908140233500710(self): + alfred.group_files(self.valid_directory) + subdir_name = "bus_0039141908140233500710" + subdir_path = os.path.join(self.valid_directory, subdir_name) + self.assertTrue(os.path.exists(subdir_path)) + self.assertTrue(os.path.isdir(subdir_path)) + expected_files = [ + '14F0154_ProfileData_20171116125343(2).csv' + ] + for file_name in expected_files: + file_path = os.path.join(subdir_path, file_name) + self.assertTrue(os.path.exists(file_path)) + self.assertTrue(os.path.isfile(file_path)) + + def test_bus_0039142006m40233500710(self): + alfred.group_files(self.valid_directory) + subdir_name = "bus_0039142006m40233500710" + subdir_path = os.path.join(self.valid_directory, subdir_name) + self.assertTrue(os.path.exists(subdir_path)) + self.assertTrue(os.path.isdir(subdir_path)) + expected_files = [ + '14B0059_ProfileData_20180403061303(2).csv' + ] + for file_name in expected_files: + file_path = os.path.join(subdir_path, file_name) + self.assertTrue(os.path.exists(file_path)) + self.assertTrue(os.path.isfile(file_path)) + + def test_bus_0039142903b40233500710(self): + alfred.group_files(self.valid_directory) + subdir_name = "bus_0039142903b40233500710" + subdir_path = os.path.join(self.valid_directory, subdir_name) + self.assertTrue(os.path.exists(subdir_path)) + self.assertTrue(os.path.isdir(subdir_path)) + expected_files = [ + '14H0221_ProfileData_20171005100537(3).csv', + '14H0221_ProfileData_20171027081821(2).csv', + '14H0221_ProfileData_20180403084955(2).csv' + ] + for file_name in expected_files: + file_path = os.path.join(subdir_path, file_name) + self.assertTrue(os.path.exists(file_path)) + self.assertTrue(os.path.isfile(file_path)) + + def test_bus_0039151006940233500710(self): + alfred.group_files(self.valid_directory) + subdir_name = "bus_0039151006940233500710" + subdir_path = os.path.join(self.valid_directory, subdir_name) + self.assertTrue(os.path.exists(subdir_path)) + self.assertTrue(os.path.isdir(subdir_path)) + expected_files = [ + '0014_ProfileData_20160727062458(2).csv', + '0014_ProfileData_20161004063626(2).csv', + '0014_ProfileData_20161201100821(2).csv', + '0014_ProfileData_20170207092734(2).csv', + '13J0014_ProfileData_20180801084738(2).csv', + '13J0014_ProfileData_20180802094539(2).csv' + ] + for file_name in expected_files: + file_path = os.path.join(subdir_path, file_name) + self.assertTrue(os.path.exists(file_path)) + self.assertTrue(os.path.isfile(file_path)) + + def test_incomplete(self): + alfred.group_files(self.valid_directory) + subdir_name = "incomplete" + subdir_path = os.path.join(self.valid_directory, subdir_name) + self.assertTrue(os.path.exists(subdir_path)) + self.assertTrue(os.path.isdir(subdir_path)) + expected_files = [ + '_ProfileData_20180425073946(2).csv', + '_ProfileData_20180508065837(2).csv' + ] + for file_name in expected_files: + file_path = os.path.join(subdir_path, file_name) + self.assertTrue(os.path.exists(file_path)) + self.assertTrue(os.path.isfile(file_path)) + + def tearDown(self): + pass + +class TestCountBusFile(unittest.TestCase): def setUp(self): - # Create a temporary directory - self.test_dir = tempfile.mkdtemp() - self.test_data_dir = os.path.join(self.test_dir, 'alfred/unsorted_test_data') - os.makedirs(self.test_data_dir) - - # Add test CSV file - self.test_file_name = '14F0154_ProfileData_20171116125343(2).csv' - self.test_file_path = os.path.join(self.test_data_dir, self.test_file_name) - with open(self.test_file_path, 'w') as f: - f.write('test data') - - def test_group_files(self): - # Call the group_files function - group_files(self.test_data_dir) + self.valid_directory = os.path.join(data_path, 'unsorted_test_data') + + def test_count_bus_file(self): + count = alfred.count_bus_file(self.valid_directory) + self.assertEqual(count, 4) + + def test_count_bus_file_returns_integer(self): + count = alfred.count_bus_file(self.valid_directory) + self.assertIsInstance(count, int) + + def tearDown(self): + pass + +class TestSortBusByDate(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'unsorted_test_data/') - # Check if the expected folder and file are created - expected_dir = os.path.join(self.test_data_dir, 'bus_0039141908140233500710') - expected_file = os.path.join(expected_dir, self.test_file_name) + def test_sort_data_by_date_returns_dataframe(self): + bus_num = 'bus_0039151006940233500710/' + df = alfred.sort_bus_by_date(self.valid_directory, bus_num) + self.assertIsInstance(df, pd.DataFrame) + + + def test_sort_data_by_date_dataframe_shape(self): + bus_num = 'bus_0039151006940233500710/' + bus_directory = os.path.join(self.valid_directory, bus_num) + csv_files = [f for f in os.listdir(bus_directory) if f.endswith('.csv')] + expected_rows = len(csv_files) + df = alfred.sort_bus_by_date(self.valid_directory, bus_num) + self.assertEqual(df.shape[0], expected_rows) + self.assertEqual(df.shape[1], 2) + + def tearDown(self): + pass - self.assertTrue(os.path.isdir(expected_dir), f"Expected directory {expected_dir} does not exist.") - self.assertTrue(os.path.isfile(expected_file), f"Expected file {expected_file} does not exist.") +class TestCompareFileMods(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'unsorted_test_data/') + self.invalid_directory = os.path.join(data_path, 'unzipped_test_data/') + + def test_compare_file_mods_returns_dictionary(self): + result = alfred.compare_file_mods(self.valid_directory) + self.assertIsInstance(result, dict) + + def test_compare_file_mods_dictionary_length(self): + result = alfred.compare_file_mods(self.valid_directory) + subdirs = [d for d in os.listdir(self.valid_directory) if os.path.isdir(os.path.join(self.valid_directory, d))] + self.assertEqual(len(result), len(subdirs)-2) # -2 to account for the .ipynb_checkpoints and incomplete subdirectories + + def test_compare_file_mods_unsorted_test_data_returns_empty_dict(self): + result = alfred.compare_file_mods(self.invalid_directory) + self.assertEqual(result, {}) + def tearDown(self): - # Remove the temporary directory after the test - shutil.rmtree(self.test_dir) + pass +class TestFilterFalseMod(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'unsorted_test_data/') + + def test_filter_false_module_returns_numpy_array(self): + result = alfred.filter_false_module(self.valid_directory) + self.assertIsInstance(result, np.ndarray) + def test_filter_false_module_contains_expected_entries(self): + expected_entries = ['bus_0039142903b40233500710', + 'bus_0039151006940233500710'] + result = alfred.filter_false_module(self.valid_directory) + for entry in expected_entries: + self.assertIn(entry, result) + + def tearDown(self): + pass + +class TestMoveFalseBus(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'sorted_test_data/') + + def test_move_false_bus_creates_vis_buses_directory(self): + alfred.move_false_bus(self.valid_directory) + # Check if 'vis_buses' directory is created + vis_buses_dir = os.path.join(self.valid_directory, 'vis_buses') + self.assertTrue(os.path.exists(vis_buses_dir)) + self.assertTrue(os.path.isdir(vis_buses_dir)) + + def test_move_false_bus_moves_correct_directories(self): + alfred.move_false_bus(self.valid_directory) + # Check if 'bus_0039142903b40233500710' and 'bus_0039151006940233500710' are in 'vis_buses' + vis_buses_dir = os.path.join(self.valid_directory, 'vis_buses') + expected_directories = ['bus_0039142903b40233500710', 'bus_0039151006940233500710'] + for directory in expected_directories: + dir_path = os.path.join(vis_buses_dir, directory) + self.assertTrue(os.path.exists(dir_path)) + self.assertTrue(os.path.isdir(dir_path)) + + def test_move_false_bus_no_other_directories_in_vis_buses(self): + alfred.move_false_bus(self.valid_directory) + # Check if there are no other directories besides 'bus_0039142903b40233500710' and 'bus_0039151006940233500710' in 'vis_buses' + vis_buses_dir = os.path.join(self.valid_directory, 'vis_buses') + expected_directories = ['bus_0039142903b40233500710', 'bus_0039151006940233500710'] + for item in os.listdir(vis_buses_dir): + if os.path.isdir(os.path.join(vis_buses_dir, item)): + self.assertIn(item, expected_directories) + + def tearDown(self): + pass + +# class TestUnpackInteractive(unittest.TestCase): +# def setUp(self): +# self.valid_directory = os.path.join(data_path, 'sorted_test_data/') +# raw_data_folder_name = 'alfred/' + 'data/' +# zip_filename = 'test_data.zip' + +# def test_unpack_interactive_creates_sorted_data_directory(self): +# alfred.etl.unpack_interactive() +# # Check if 'sorted_data' directory is created +# sorted_data_dir = os.path.join(self.valid_directory, 'sorted_data') +# self.assertTrue(os.path.exists(sorted_data_dir)) +# self.assertTrue(os.path.isdir(sorted_data_dir)) + +# def test_unpack_interactive_creates_all_buses_directory(self): +# alfred.etl.unpack_interactive() +# # Check if 'all_buses' directory is created +# all_buses_dir = os.path.join(self.valid_directory, 'all_buses') +# self.assertTrue(os.path.exists(all_buses_dir)) +# self.assertTrue(os.path.isdir(all_buses_dir)) +# def tearDown(self): +# pass + if __name__ == '__main__': unittest.main() diff --git a/alfred/tests/test_vis.py b/alfred/tests/test_vis.py index 134d427..9346ab3 100644 --- a/alfred/tests/test_vis.py +++ b/alfred/tests/test_vis.py @@ -5,74 +5,287 @@ import pandas as pd import shutil import alfred +import altair as alt +import matplotlib.pyplot as plt #import etl #from vis import build_bus_df -data_path = os.path.join(alfred.__path__[0], 'data') +data_path = os.path.join(alfred.__path__[0], 'data/sorted_test_data') +bad_data_path = os.path.join(alfred.__path__[0], 'data/sorted_test_data') class TestBuildBusDF(unittest.TestCase): def setUp(self): - # Setup code here if needed - self.valid_directory = os.path.join(alfred.etl.find_directory(), 'alfred/sorted_test_data/vis_buses/') + self.valid_directory = os.path.join(data_path, 'vis_buses/') self.bus_num = "bus_0039142903b40233500710/" #self.valid_keywords = ["Current", "Voltage", "Power"] def test_dataframe_creation_current(self): # Test to ensure a DataFrame is created for 'Current' keyword = "Current" - result = alfred.vis.build_bus_df(self.valid_directory, self.bus_num, keyword) + result = alfred.build_bus_df(self.valid_directory, self.bus_num, keyword) self.assertIsInstance(result, pd.DataFrame, "The result should be a pandas DataFrame for 'Current'") def test_dataframe_creation_voltage(self): # Test to ensure a DataFrame is created for 'Voltage' keyword = "Voltage" - result = alfred.vis.build_bus_df(self.valid_directory, self.bus_num, keyword) + result = alfred.build_bus_df(self.valid_directory, self.bus_num, keyword) self.assertIsInstance(result, pd.DataFrame, "The result should be a pandas DataFrame for 'Voltage'") def test_dataframe_creation_power(self): # Test to ensure a DataFrame is created for 'Power' keyword = "Power" - result = alfred.vis.build_bus_df(self.valid_directory, self.bus_num, keyword) + result = alfred.build_bus_df(self.valid_directory, self.bus_num, keyword) self.assertIsInstance(result, pd.DataFrame, "The result should be a pandas DataFrame for 'Power'") def tearDown(self): - # Clean up code here if needed + pass class TestBuildModuleDF(unittest.TestCase): def setUp(self): - # Setup code here if needed - self.valid_directory = os.path.join(alfred.etl.find_directory(), 'alfred/sorted_test_data/vis_buses/') - self.invalid_directory = os.path.join('alfred/sorted_test_data/sorted_data/incomplete_test/') + + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.invalid_directory = os.path.join(bad_data_path, 'sorted_data/incomplete_test/') self.bus_num = "bus_0039142903b40233500710/" def test_dataframe_creation_for_valid_numbers(self): # Test to ensure a DataFrame is created for each valid number from 1 to 16 for num in range(1, 17): with self.subTest(num=num): - result = alfred.vis.build_module_df(self.valid_directory, self.bus_num, num) + result = alfred.build_module_df(self.valid_directory, self.bus_num, num) self.assertIsInstance(result, pd.DataFrame, f"The result should be a pandas DataFrame for module number {num}") def test_no_dataframe_creation_for_invalid_data(self): # Test to ensure no DataFrame is created for invalid/incomplete data num = 1 try: - result = alfred.vis.build_module_df(self.invalid_directory, self.bus_num, num) + result = alfred.build_module_df(self.invalid_directory, self.bus_num, num) # Check if the function returns None or handles the case gracefully self.assertIsNone(result, "The result should be None for invalid/incomplete data") except Exception as e: # If an exception is raised, ensure it's the expected behavior self.assertIsInstance(e, (FileNotFoundError, pd.errors.EmptyDataError), "Expected an error due to invalid data") def test_invalid_number_input(self): - # Test to ensure no DataFrame is created for invalid module number - invalid_numbers = [ 17, -1, 'a'] - for num in invalid_numbers: + # Test to ensure no DataFrame is created for invalid module number + invalid_numbers = [ 17, -1, 'DavidBeck'] + for num in invalid_numbers: + with self.subTest(num=num): + with self.assertRaises((ValueError, TypeError), msg=f"Expected a ValueError or TypeError for invalid module number {num}"): + alfred.build_module_df(self.valid_directory, self.bus_num, num) + + def tearDown(self): + + pass + +data_path = os.path.join(alfred.__path__[0], 'data/sorted_test_data') +bad_data_path = os.path.join(alfred.__path__[0], 'data/sorted_test_data') + +class TestBuildTempDF(unittest.TestCase): + def setUp(self): + + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.invalid_directory = os.path.join(bad_data_path, 'sorted_data/incomplete_test/') + self.bus_num = "bus_0039142903b40233500710/" + + def test_dataframe_creation_for_valid_numbers_temp(self): + # Test to ensure a DataFrame is created for each valid number from 1 to 16 + for num in range(1, 17): + with self.subTest(num=num): + result = alfred.build_module_temp(self.valid_directory, self.bus_num, num) + self.assertIsInstance(result, pd.DataFrame, f"The result should be a pandas DataFrame for module number {num}") + def test_no_dataframe_creation_for_invalid_data_temp(self): + # Test to ensure no DataFrame is created for invalid/incomplete data + num = 1 + try: + result = alfred.build_module_temp(self.invalid_directory, self.bus_num, num) + # Check if the function returns None or handles the case gracefully + self.assertIsNone(result, "The result should be None for invalid/incomplete data") + except Exception as e: + # If an exception is raised, ensure it's the expected behavior + self.assertIsInstance(e, (FileNotFoundError, pd.errors.EmptyDataError), "Expected an error due to invalid data") + + def test_invalid_number_input_temp(self): + # Test to ensure no DataFrame is created for invalid module number + invalid_numbers = [ 17, -1, 'DavidBeck'] + for num in invalid_numbers: + with self.subTest(num=num): + with self.assertRaises((ValueError, TypeError), msg=f"Expected a ValueError or TypeError for invalid module number {num}"): + alfred.build_module_temp(self.valid_directory, self.bus_num, num) + def tearDown(self): + + pass + +class TestBuildAvg(unittest.TestCase): + def setUp(self): + + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.invalid_directory = os.path.join(bad_data_path, 'sorted_data/incomplete_test/') + self.bus_num = "bus_0039151006940233500710/" + + def test_dataframe_creation_for_valid_numbers_avg(self): + # Test to ensure a DataFrame is created for each valid number from 1 to 16 + for num in range(1, 17): with self.subTest(num=num): - with self.assertRaises((ValueError, TypeError), msg=f"Expected a ValueError or TypeError for invalid module number {num}"): - alfred.vis.build_module_df(self.valid_directory, self.bus_num, num) + result = alfred.build_module_average_df(self.valid_directory, self.bus_num, num) + self.assertIsInstance(result, pd.DataFrame, f"The result should be a pandas DataFrame for module number {num}") + def test_no_dataframe_creation_for_invalid_data_avg(self): + # Test to ensure no DataFrame is created for invalid/incomplete data + num = 1 + try: + result = alfred.build_module_average_df(self.invalid_directory, self.bus_num, num) + # Check if the function returns None or handles the case gracefully + self.assertIsNone(result, "The result should be None for invalid/incomplete data") + except Exception as e: + # If an exception is raised, ensure it's the expected behavior + self.assertIsInstance(e, (FileNotFoundError, pd.errors.EmptyDataError), "Expected an error due to invalid data") + def test_invalid_number_input_avg(self): + # Test to ensure no DataFrame is created for invalid module number + invalid_numbers = [ 17, -1, 'DavidBeck'] + for num in invalid_numbers: + with self.subTest(num=num): + with self.assertRaises((ValueError, TypeError), msg=f"Expected a ValueError or TypeError for invalid module number {num}"): + alfred.build_module_average_df(self.valid_directory, self.bus_num, num) + def test_invalid_number_input_avg_keyerror(self): + # Test for KeyError when module_num is 0 + with self.assertRaises(KeyError): + alfred.build_module_average_df(self.valid_directory, self.bus_num, 0) + + def tearDown(self): + + pass + +class TestVisualizeModTime(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.bus_num = 'bus_0039151006940233500710/' + self.module_num = 1 + + def test_visualize_mod_time_output(self): + # Call the function with test inputs + chart = alfred.visualize_mod_time(self.valid_directory, self.bus_num, self.module_num) + + # Check that the output is an Altair Chart object + self.assertIsInstance(chart, alt.Chart) + + # Optional: You can add more checks, for example, verifying the chart properties + self.assertIn('mark_line', dir(chart)) + + def test_visualize_mod_time_invalid_module_num(self): + # List of invalid module numbers to test + invalid_module_nums = [-1, 17] + + for module_num in invalid_module_nums: + with self.assertRaises(ValueError): + alfred.visualize_mod_time(self.valid_directory, self.bus_num, module_num) + + def test_visualize_mod_time_key_error(self): + # Test for KeyError when module_num is 0 + with self.assertRaises(KeyError): + alfred.visualize_mod_time(self.valid_directory, self.bus_num, 0) + + def test_visualize_mod_time_type_error(self): + # Test for TypeError when module_num is 'DavidBeck' + with self.assertRaises(TypeError): + alfred.visualize_mod_time(self.valid_directory, self.bus_num, 'DavidBeck') + + def tearDown(self): + + pass + +class TestCountModChanges(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + + def test_count_mod_changes_output(self): + + df = alfred.count_mod_changes(self.valid_directory) + + # Check that the output is a DataFrame + self.assertIsInstance(df, pd.DataFrame) + + def test_count_mod_changes_columns(self): + + df = alfred.count_mod_changes(self.valid_directory) + + # Check that the DataFrame has 4 columns + self.assertEqual(df.shape[1], 4) + + def test_count_mod_changes_rows_divisible_by_16(self): + + df = alfred.count_mod_changes(self.valid_directory) + # Check that the number of rows is divisible by 16 + self.assertEqual(df.shape[0] % 16, 0) + def tearDown(self): + + pass + +class TestVisualiseModChanges(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + + def test_visualise_mod_changes_output(self): + chart = alfred.visualise_mod_changes(self.valid_directory) + self.assertIsInstance(chart, alt.Chart) + + def tearDown(self): + + pass +class TestModChangeStatistics(unittest.TestCase): + + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.empty_data_directory = os.path.join(data_path, 'sorted_data/') + + def test_mod_change_statistics_output(self): + ax= alfred.mod_change_statistics(self.valid_directory) + self.assertIsInstance(ax, plt.Axes) + + def test_mod_change_statistics_empty_data_directory(self): + ax = alfred.mod_change_statistics(self.empty_data_directory) + # Check if the chart is blank (no data) + has_data = any([line.get_data()[0].size > 0 for line in ax.get_lines()]) + self.assertFalse(has_data, "The chart is not blank") def tearDown(self): - # Clean up code here if needed + pass +class TestFindReplacedModules(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.empty_data_directory = os.path.join(data_path, 'sorted_data/') + + def testfind_replaced_mod_dict_is_made(self): + + result = alfred.find_replaced_modules(self.valid_directory) + + # Check if the returned object is a dictionary + self.assertIsInstance(result, dict, "The returned object is not a dictionary") + + def test_replaced_mod_dict_is_empty(self): + # Call the function with an empty directory + result = alfred.find_replaced_modules(self.empty_data_directory) + + # Check if the returned dictionary is empty + self.assertEqual(len(result), 0, "The returned dictionary is not empty") + def tearDown(self): + + pass + +class TestSwappedModDataframes(unittest.TestCase): + def setUp(self): + self.valid_directory = os.path.join(data_path, 'vis_buses/') + self.serial_num = '0039-1429-03B-402335-00710' + self.characteristics = ['cell voltages', 'balancers', 'temperatures', 'module voltages'] + + def test_return_type(self): + for characteristic in self.characteristics: + with self.subTest(characteristic=characteristic): + result = alfred.swapped_mod_dataframes(self.valid_directory, self.serial_num, characteristic) + # Check if the returned object is a list + self.assertIsInstance(result, list, f"The returned object is not a list for characteristic: {characteristic}") + def tearDown(self): + + pass + if __name__ == '__main__': unittest.main() \ No newline at end of file diff --git a/alfred/vis.py b/alfred/vis.py index 42f12a3..54da5f0 100644 --- a/alfred/vis.py +++ b/alfred/vis.py @@ -8,67 +8,6 @@ from .etl import find_directory, sort_bus_by_date -# def find_directory(): -# ''' -# Assuming your python file is in the directory containing KCM data files, -# returns a path to that directory with an additional -# forward slash for future concatenation processes. -# ''' -# path = pathlib.Path().absolute() -# directory = str(path) + '/' -# return directory - - -# def sort_bus_by_date(directory, bus_num): -# ''' -# Creates a DataFrame of bus files sorted by the date they were retrieved. - -# Parameters: -# - directory (str): The directory where the bus files are located. -# - bus_num (str): The desired bus, written as "bus_" followed by the bus serial number. -# ''' -# # find directory of bus from sorted files -# bus_directory = directory + bus_num - -# # make list of all files in bus folder -# csv_list = [] -# for file in listdir(bus_directory): -# if file.endswith('.csv'): -# csv_list.append(file) - -# # make a list of dates and initialize final columns for dataframe -# list_of_dates = [] -# substring = 'Data retrieved' -# cols = ['Filename', 'DateRetrieved'] - -# for filename in csv_list: -# with open(bus_directory + filename) as file: -# reader = csv.reader(file) -# for row in reader: -# try: -# for element in row: -# if substring in element: -# # print(filename, '|', element) -# list_of_dates.append(element) -# except IndexError: -# pass # some files have no data - -# # pull out the 'Date Retrieved' and @ symbol from the date column -# for i in range(len(list_of_dates)): -# date = list_of_dates[i] -# list_of_dates[i] = date[16:].replace('@', '') - -# # make the dataframe of filenames and dates -# list_of_tuples = list(zip(csv_list, list_of_dates)) -# files_dates = pd.DataFrame(list_of_tuples, columns=cols) - -# # sort by date -# files_dates['DateRetrieved'] = pd.to_datetime(files_dates.DateRetrieved) -# files_dates.sort_values('DateRetrieved', inplace=True) -# files_dates.reset_index(drop=True, inplace=True) - -# return files_dates - def build_bus_df(directory, bus_num, keyword): ''' @@ -471,7 +410,7 @@ def find_replaced_modules(directory): bus_swapped_mods = {} # Storing modules that have been swapped with each bus number for folder in listdir(directory): - if folder.startswith('bus'): + if folder.startswith('bus_'): bus = folder bus_slash = folder + '/' replaced_mods = set()