From 2e748ba9e360617d6ba7be11c4c041d69b7eb808 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Mon, 1 Aug 2022 12:10:41 +0000 Subject: [PATCH 1/7] added unit tests file. --- .../scripts/ls_metrics/listing_benchmark_test.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 perfmetrics/scripts/ls_metrics/listing_benchmark_test.py diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py new file mode 100644 index 0000000000..57373ff1c0 --- /dev/null +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -0,0 +1,14 @@ +"""Tests for listing_benchmark.""" + +from usr.local.google.home.topgunpranjal.Desktop.Development.unittest.gcsfuse.perfmetrics.scripts.ls_metrics import listing_benchmark +from google3.testing.pybase import googletest + + +class ListingBenchmarkTest(googletest.TestCase): + + def test_give_me_a_name(self): + pass + + +if __name__ == '__main__': + googletest.main() From be8ad842de068bf9517401cf2dd04aeb53169bb9 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Tue, 2 Aug 2022 13:38:10 +0000 Subject: [PATCH 2/7] unit test written & done some fixing in listing benchmark --- .../scripts/ls_metrics/listing_benchmark.py | 11 +- .../ls_metrics/listing_benchmark_test.py | 453 +++++++++++++++++- 2 files changed, 452 insertions(+), 12 deletions(-) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark.py b/perfmetrics/scripts/ls_metrics/listing_benchmark.py index 5be8fed808..b697b1a521 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark.py @@ -83,7 +83,7 @@ def _parse_results(folders, results_list, message, num_samples) -> dict: results_list[testing_folder.name] = sorted(results_list[testing_folder.name]) metrics[testing_folder.name]['Mean'] = stat.mean(results_list[testing_folder.name]) metrics[testing_folder.name]['Median'] = stat.median(results_list[testing_folder.name]) - metrics[testing_folder.name]['Standard Dev'] = stat.stdev(gcs_bucket_results[testing_folder.name]) + metrics[testing_folder.name]['Standard Dev'] = stat.stdev(results_list[testing_folder.name]) metrics[testing_folder.name]['Quantiles'] = dict() for percentile in range(0, 100, 20): @@ -200,20 +200,19 @@ def _create_directory_structure(gcs_bucket_url, persistent_disk_url, directory_s return int(result > 0) -def _list_directory(path) -> (list, int): +def _list_directory(path) -> list: """Returns the list containing path of all the contents present in the current directory and also the number of contents. Args: path: Path of the directory. Returns: - A list containing path of all contents present in the input path. Also returns the number of contents. + A list containing path of all contents present in the input path. """ contents = subprocess.check_output('gsutil -m ls {}'.format(path), shell=True) contents_url = contents.decode('utf-8').split('\n')[:-1] - num_contents = len(contents_url) - return contents_url, num_contents + return contents_url def _compare_directory_structure(url, directory_structure) -> bool: @@ -227,7 +226,7 @@ def _compare_directory_structure(url, directory_structure) -> bool: True if GCS bucket contents matches the directory structure. """ - contents_url, num_contents = _list_directory(url) + contents_url = _list_directory(url) # gsutil in some cases return the contents_url list with the current directory in # the first index. We dont want the current directory so we remove it # manually. diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index 57373ff1c0..a1970dda5d 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -1,14 +1,455 @@ """Tests for listing_benchmark.""" -from usr.local.google.home.topgunpranjal.Desktop.Development.unittest.gcsfuse.perfmetrics.scripts.ls_metrics import listing_benchmark -from google3.testing.pybase import googletest +import listing_benchmark +import unittest +from unittest import mock +from mock import patch, call +import directory_pb2 as directory_proto +from google.protobuf.json_format import Parse, ParseDict +# (Type 1) - 0 levels deep directory structure. +DIRECTORY_STRUCTURE1 = { + "name": "fake_bucket" +} -class ListingBenchmarkTest(googletest.TestCase): +# (Type 2) - 1 level deep directory structure with an empty testing folder. +DIRECTORY_STRUCTURE2 = { + "name": "fake_bucket" , + "num_folders": 3 , + "num_files": 1 , + "file_size": "1kb" , + "file_name_prefix": "file" , + "folders": [ + { + "name": "2KB_3files_0subdir" , + "num_files": 3 , + "file_name_prefix": "file" , + "file_size": "2kb" + } , + { + "name": "1KB_2files_0subdir" , + "num_files": 2 , + "file_size": "1kb" , + "file_name_prefix": "file" + } , + { + "name": "1KB_0files_0subdir" + } + ] +} - def test_give_me_a_name(self): - pass +# (Type 3) - Multilevel deep directory structure with many edge cases embedded. +DIRECTORY_STRUCTURE3 = { + "name": "fake_bucket" , + "num_folders": 3 , + "num_files": 0, + "folders": [ + { + "name": "1KB_4files_3subdir" , + "num_files": 4 , + "file_name_prefix": "file" , + "file_size": "1kb" , + "num_folders": 3 , + "folders": [ + { + "name": "subdir1" , + "num_files": 1 , + "file_name_prefix": "file" , + "file_size": "1kb" , + "num_folders": 2, + "folders": [ + { + "name": "subsubdir1" , + "num_files": 2, + "file_name_prefix": "file" , + "file_size": "1kb" + } , + { + "name": "subsubdir2" + } + ] + } , + { + "name": "subdir2" , + "num_files": 1 , + "file_name_prefix": "file" , + "file_size": "1kb" + } , + { + "name": "subdir3" , + "num_files": 1 , + "file_name_prefix": "file" , + "file_size": "1kb" , + "num_folders": 1 , + "folders": [ + { + "name": "subsubdir1" , + "num_files": 1 , + "file_name_prefix": "file" , + "file_size": "1kb" + } + ] + } + ] + } , + { + "name": "2KB_3files_1subdir" , + "num_files": 3 , + "file_name_prefix": "file" , + "file_size": "2kb" , + "num_folders": 1 , + "folders": [ + { + "name": "subdir1" + } + ] + } , + { + "name": "1KB_1files_0subdir" , + "num_files": 1 , + "file_size": "1kb" , + "file_name_prefix": "file" + } + ] +} +METRICS1 = [1.234, 0.995, 0.121, 0.222, 0.01709] +METRICS2 = [90.45, 1.95, 0.334, 7.090, 0.001] +METRICS3 = [100, 7, 6, 51, 21] + +DIRECTORY_STRUCTURE1 = ParseDict(DIRECTORY_STRUCTURE1, directory_proto.Directory()) +DIRECTORY_STRUCTURE2 = ParseDict(DIRECTORY_STRUCTURE2, directory_proto.Directory()) +DIRECTORY_STRUCTURE3 = ParseDict(DIRECTORY_STRUCTURE3, directory_proto.Directory()) + +class ListingBenchmarkTest(unittest.TestCase): + + def test_parse_results_type1(self): + metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE1.folders, {}, "fake_test", 5) + self.assertEqual(metrics, {}) + + def test_parse_results_type2(self): + metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { + "2KB_3files_0subdir": METRICS1, + "1KB_2files_0subdir": METRICS2, + "1KB_0files_0subdir": METRICS3 + }, "fake_test", 5) + + self.assertEqual(metrics, + { + '2KB_3files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 0.517818, + 'Median': 0.222, + 'Standard Dev': 0.5559497869592182, + 'Quantiles': + { + '0 %ile': 0.01709, + '20 %ile': 0.100218, + '40 %ile': 0.1816, + '60 %ile': 0.5311999999999999, + '80 %ile': 1.0428, + '90 %ile': 1.1384, + '95 %ile': 1.1862, + '98 %ile': 1.21488, + '99 %ile': 1.22444, + '100 %ile': 1.234 + } + }, + '1KB_2files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 19.965, + 'Median': 1.95, + 'Standard Dev': 39.504362202166995, + 'Quantiles': + { + '0 %ile': 0.001, + '20 %ile': 0.2674, + '40 %ile': 1.3036, + '60 %ile': 4.005999999999999, + '80 %ile': 23.762000000000015, + '90 %ile': 57.10600000000001, + '95 %ile': 73.77799999999999, + '98 %ile': 83.7812, + '99 %ile': 87.1156, + '100 %ile': 90.45 + } + }, + '1KB_0files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 37, + 'Median': 21, + 'Standard Dev': 39.62953444086872, + 'Quantiles': + { + '0 %ile': 6.0, + '20 %ile': 6.8, + '40 %ile': 15.400000000000002, + '60 %ile': 33.0, + '80 %ile': 60.80000000000001, + '90 %ile': 80.4, + '95 %ile': 90.19999999999999, + '98 %ile': 96.08, + '99 %ile': 98.03999999999999, + '100 %ile': 100.0 + } + } + } + ) + + @patch("listing_benchmark.subprocess.call", return_value = 1) + @patch("listing_benchmark.time.time", return_value = 1) + def test_record_time_of_operation(self, mock_time, mock_subprocess_call): + result_list = listing_benchmark._record_time_of_operation("ls", "fakepath/", 5) + self.assertEqual(mock_subprocess_call.call_count, 5) + self.assertEqual(result_list, [0, 0, 0, 0, 0]) + + @patch("listing_benchmark._record_time_of_operation") + def test_perform_testing_type1(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE1.folders, + "fake_bucket", "fake_disk", 3, "ls -R") + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertFalse(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, {}) + + @patch("listing_benchmark._record_time_of_operation") + def test_perform_testing_type2(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE2.folders, + "fake_bucket", "fake_disk", 3, "ls -R") + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + "2KB_3files_0subdir": [1, 1, 1], + "1KB_2files_0subdir": [1, 1, 1], + "1KB_0files_0subdir": [1, 1, 1] + }) + + @patch("listing_benchmark._record_time_of_operation", return_value = [1]) + def test_perform_testing_type3(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE3.folders, + "fake_bucket", "fake_disk", 2, "ls -R") + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + "1KB_4files_3subdir": [1, 1], + "2KB_3files_1subdir": [1, 1], + "1KB_1files_0subdir": [1, 1] + }) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) + def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", + DIRECTORY_STRUCTURE1, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 1) + self.assertEqual(mock_generate_files.call_count, 0) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, []) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) + def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", + DIRECTORY_STRUCTURE2, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/2KB_3files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_2files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_0files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/', 1, 'kb', 1, 'file', 'fake_disk_url/', True), + call('fake_bucket_url/2KB_3files_0subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_0subdir/', True), + call('fake_bucket_url/1KB_2files_0subdir/', 2, 'kb', 1, 'file', 'fake_disk_url/1KB_2files_0subdir/', True) + ]) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) + def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", + DIRECTORY_STRUCTURE3, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 11) + self.assertEqual(mock_generate_files.call_count, 8) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/subsubdir1/', 2, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir2/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir2/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/subsubdir1/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 1) + def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", + DIRECTORY_STRUCTURE3, True) + self.assertTrue(exit_code > 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_true_type1(self, mock_list): + mock_list.side_effect = [["fake_bucket/"]] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE1) + self.assertTrue(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_true_type2(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], + ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], + ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], + [] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) + self.assertTrue(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], + ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], + ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], + ["fake_bucket/1KB_0files_0subdir/file_1"] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_false_folder_type2(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], + ["fake_bucket/2KB_3files_0subdir/dummy_folder/", "fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], + ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], + [] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], + ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], + ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], + [] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_true_type3(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/1KB_4files_3subdir/", "fake_bucket/2KB_3files_1subdir/", "fake_bucket/1KB_1files_0subdir/"], + ["fake_bucket/1KB_4files_3subdir/file_1", "fake_bucket/1KB_4files_3subdir/file_2", "fake_bucket/1KB_4files_3subdir/file_3", "fake_bucket/1KB_4files_3subdir/file_4", + "fake_bucket/1KB_4files_3subdir/subdir1/", "fake_bucket/1KB_4files_3subdir/subdir2/", "fake_bucket/1KB_4files_3subdir/subdir3/"], + ["fake_bucket/1KB_4files_3subdir/subdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/"], + ["fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2"], + [], + ["fake_bucket/1KB_4files_3subdir/subdir2/file_1"], + ["fake_bucket/1KB_4files_3subdir/subdir3/file_1", "fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/"], + ["fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1"], + ["fake_bucket/2KB_3files_1subdir/file_1", "fake_bucket/2KB_3files_1subdir/file_2", "fake_bucket/2KB_3files_1subdir/file_3", "fake_bucket/2KB_3files_1subdir/subdir1/"], + [], + ["fake_bucket/1KB_1files_0subdir/file_1"] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE3) + self.assertTrue(result) + + @patch("listing_benchmark._list_directory") + def test_compare_directory_structure_false_file_folder_type3(self, mock_list): + mock_list.side_effect = [ + ["fake_bucket/", "fake_bucket/file1", "fake_bucket/1KB_4files_3subdir/", "fake_bucket/2KB_3files_1subdir/", "fake_bucket/1KB_1files_0subdir/"], + ["fake_bucket/1KB_4files_3subdir/file_1", "fake_bucket/1KB_4files_3subdir/file_2", "fake_bucket/1KB_4files_3subdir/file_3", "fake_bucket/1KB_4files_3subdir/file_4", + "fake_bucket/1KB_4files_3subdir/subdir1/", "fake_bucket/1KB_4files_3subdir/subdir2/", "fake_bucket/1KB_4files_3subdir/subdir3/"], + ["fake_bucket/1KB_4files_3subdir/subdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/"], + ["fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2"], + [], + ["fake_bucket/1KB_4files_3subdir/subdir2/file_1"], + ["fake_bucket/1KB_4files_3subdir/subdir3/file_1", "fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/"], + ["fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1"], + ["fake_bucket/2KB_3files_1subdir/file_1", "fake_bucket/2KB_3files_1subdir/file_2", "fake_bucket/2KB_3files_1subdir/file_3", "fake_bucket/2KB_3files_1subdir/subdir1/"], + ["fake_bucket/2KB_3files_1subdir/subdir1/file_1", "fake_bucket/2KB_3files_1subdir/subdir1/dummy_folder/"], + ["fake_bucket/1KB_1files_0subdir/file_1"] + ] + result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE3) + self.assertFalse(result) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + def test_unmount_gcs_bucket(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket("fake_bucket") + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call("umount -l fake_bucket", shell=True)) + self.assertEqual(mock_subprocess_call.call_args_list[1], call("rm -rf fake_bucket", shell=True)) + + @patch("listing_benchmark.subprocess.call", return_value = 1) + def test_unmount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket("fake_bucket") + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call("umount -l fake_bucket", shell=True)) + self.assertEqual(mock_subprocess_call.call_args_list[1], call("bash", shell=True)) + + @patch("listing_benchmark.subprocess.call", return_value = 0) + def test_mount_gcs_bucket(self, mock_subprocess_call): + directory_name = listing_benchmark._mount_gcs_bucket("fake_bucket") + self.assertEqual(directory_name, "fake_bucket") + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call("mkdir fake_bucket", shell=True), + call("gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket", shell=True) + ]) + + @patch("listing_benchmark.subprocess.call", return_value = 1) + def test_mount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._mount_gcs_bucket("fake_bucket") + self.assertEqual(mock_subprocess_call.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call("mkdir fake_bucket", shell=True), + call("gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket", shell=True), + call("bash", shell=True) + ]) if __name__ == '__main__': - googletest.main() + unittest.main() From c6fced24c008c3365d62ef943b346f17ac0fafe1 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Tue, 2 Aug 2022 14:40:29 +0000 Subject: [PATCH 3/7] formatted code. --- .../ls_metrics/listing_benchmark_test.py | 877 ++++++++++-------- 1 file changed, 466 insertions(+), 411 deletions(-) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index a1970dda5d..5f579162f6 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -9,447 +9,502 @@ # (Type 1) - 0 levels deep directory structure. DIRECTORY_STRUCTURE1 = { - "name": "fake_bucket" + 'name': 'fake_bucket' } # (Type 2) - 1 level deep directory structure with an empty testing folder. DIRECTORY_STRUCTURE2 = { - "name": "fake_bucket" , - "num_folders": 3 , - "num_files": 1 , - "file_size": "1kb" , - "file_name_prefix": "file" , - "folders": [ - { - "name": "2KB_3files_0subdir" , - "num_files": 3 , - "file_name_prefix": "file" , - "file_size": "2kb" - } , - { - "name": "1KB_2files_0subdir" , - "num_files": 2 , - "file_size": "1kb" , - "file_name_prefix": "file" - } , - { - "name": "1KB_0files_0subdir" - } - ] + 'name': 'fake_bucket', + 'num_folders': 3, + 'num_files': 1, + 'file_size': '1kb', + 'file_name_prefix': 'file', + 'folders': [ + { + 'name': '2KB_3files_0subdir', + 'num_files': 3, + 'file_name_prefix': 'file', + 'file_size': '2kb' + }, + { + 'name': '1KB_2files_0subdir', + 'num_files': 2, + 'file_size': '1kb', + 'file_name_prefix': 'file' + }, + { + 'name': '1KB_0files_0subdir' + } + ] } # (Type 3) - Multilevel deep directory structure with many edge cases embedded. DIRECTORY_STRUCTURE3 = { - "name": "fake_bucket" , - "num_folders": 3 , - "num_files": 0, - "folders": [ - { - "name": "1KB_4files_3subdir" , - "num_files": 4 , - "file_name_prefix": "file" , - "file_size": "1kb" , - "num_folders": 3 , - "folders": [ - { - "name": "subdir1" , - "num_files": 1 , - "file_name_prefix": "file" , - "file_size": "1kb" , - "num_folders": 2, - "folders": [ + 'name': 'fake_bucket', + 'num_folders': 3, + 'num_files': 0, + 'folders': [ + { + 'name': '1KB_4files_3subdir', + 'num_files': 4, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 3, + 'folders': [ + { + 'name': 'subdir1', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 2, + 'folders': [ { - "name": "subsubdir1" , - "num_files": 2, - "file_name_prefix": "file" , - "file_size": "1kb" - } , + 'name': 'subsubdir1', + 'num_files': 2, + 'file_name_prefix': 'file', + 'file_size': '1kb' + }, { - "name": "subsubdir2" + 'name': 'subsubdir2' } ] - } , - { - "name": "subdir2" , - "num_files": 1 , - "file_name_prefix": "file" , - "file_size": "1kb" - } , - { - "name": "subdir3" , - "num_files": 1 , - "file_name_prefix": "file" , - "file_size": "1kb" , - "num_folders": 1 , - "folders": [ + }, + { + 'name': 'subdir2', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb' + }, + { + 'name': 'subdir3', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 1, + 'folders': [ { - "name": "subsubdir1" , - "num_files": 1 , - "file_name_prefix": "file" , - "file_size": "1kb" + 'name': 'subsubdir1', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb' } ] - } + } ] - } , - { - "name": "2KB_3files_1subdir" , - "num_files": 3 , - "file_name_prefix": "file" , - "file_size": "2kb" , - "num_folders": 1 , - "folders": [ + }, + { + 'name': '2KB_3files_1subdir', + 'num_files': 3, + 'file_name_prefix': 'file', + 'file_size': '2kb', + 'num_folders': 1, + 'folders': [ { - "name": "subdir1" + 'name': 'subdir1' } ] - } , - { - "name": "1KB_1files_0subdir" , - "num_files": 1 , - "file_size": "1kb" , - "file_name_prefix": "file" + }, + { + 'name': '1KB_1files_0subdir', + 'num_files': 1, + 'file_size': '1kb', + 'file_name_prefix': 'file' } - ] + ] } METRICS1 = [1.234, 0.995, 0.121, 0.222, 0.01709] METRICS2 = [90.45, 1.95, 0.334, 7.090, 0.001] METRICS3 = [100, 7, 6, 51, 21] -DIRECTORY_STRUCTURE1 = ParseDict(DIRECTORY_STRUCTURE1, directory_proto.Directory()) -DIRECTORY_STRUCTURE2 = ParseDict(DIRECTORY_STRUCTURE2, directory_proto.Directory()) -DIRECTORY_STRUCTURE3 = ParseDict(DIRECTORY_STRUCTURE3, directory_proto.Directory()) +DIRECTORY_STRUCTURE1 = ParseDict( + DIRECTORY_STRUCTURE1, directory_proto.Directory()) +DIRECTORY_STRUCTURE2 = ParseDict( + DIRECTORY_STRUCTURE2, directory_proto.Directory()) +DIRECTORY_STRUCTURE3 = ParseDict( + DIRECTORY_STRUCTURE3, directory_proto.Directory()) + class ListingBenchmarkTest(unittest.TestCase): - def test_parse_results_type1(self): - metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE1.folders, {}, "fake_test", 5) - self.assertEqual(metrics, {}) + def test_parse_results_type1(self): + metrics = listing_benchmark._parse_results( + DIRECTORY_STRUCTURE1.folders, {}, 'fake_test', 5) + self.assertEqual(metrics, {}) - def test_parse_results_type2(self): - metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { - "2KB_3files_0subdir": METRICS1, - "1KB_2files_0subdir": METRICS2, - "1KB_0files_0subdir": METRICS3 - }, "fake_test", 5) + def test_parse_results_type2(self): + metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { + '2KB_3files_0subdir': METRICS1, + '1KB_2files_0subdir': METRICS2, + '1KB_0files_0subdir': METRICS3 + }, 'fake_test', 5) + + self.assertEqual(metrics, + { + '2KB_3files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 0.517818, + 'Median': 0.222, + 'Standard Dev': 0.5559497869592182, + 'Quantiles': + { + '0 %ile': 0.01709, + '20 %ile': 0.100218, + '40 %ile': 0.1816, + '60 %ile': 0.5311999999999999, + '80 %ile': 1.0428, + '90 %ile': 1.1384, + '95 %ile': 1.1862, + '98 %ile': 1.21488, + '99 %ile': 1.22444, + '100 %ile': 1.234 + } + }, + '1KB_2files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 19.965, + 'Median': 1.95, + 'Standard Dev': 39.504362202166995, + 'Quantiles': + { + '0 %ile': 0.001, + '20 %ile': 0.2674, + '40 %ile': 1.3036, + '60 %ile': 4.005999999999999, + '80 %ile': 23.762000000000015, + '90 %ile': 57.10600000000001, + '95 %ile': 73.77799999999999, + '98 %ile': 83.7812, + '99 %ile': 87.1156, + '100 %ile': 90.45 + } + }, + '1KB_0files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 37, + 'Median': 21, + 'Standard Dev': 39.62953444086872, + 'Quantiles': + { + '0 %ile': 6.0, + '20 %ile': 6.8, + '40 %ile': 15.400000000000002, + '60 %ile': 33.0, + '80 %ile': 60.80000000000001, + '90 %ile': 80.4, + '95 %ile': 90.19999999999999, + '98 %ile': 96.08, + '99 %ile': 98.03999999999999, + '100 %ile': 100.0 + } + } + } + ) + + @patch('listing_benchmark.subprocess.call', return_value=1) + @patch('listing_benchmark.time.time', return_value=1) + def test_record_time_of_operation(self, mock_time, mock_subprocess_call): + result_list = listing_benchmark._record_time_of_operation( + 'ls', 'fakepath/', 5) + self.assertEqual(mock_subprocess_call.call_count, 5) + self.assertEqual(result_list, [0, 0, 0, 0, 0]) + + @patch('listing_benchmark._record_time_of_operation') + def test_perform_testing_type1(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE1.folders, + 'fake_bucket', 'fake_disk', 3, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertFalse(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, {}) + + @patch('listing_benchmark._record_time_of_operation') + def test_perform_testing_type2(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE2.folders, + 'fake_bucket', 'fake_disk', 3, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + '2KB_3files_0subdir': [1, 1, 1], + '1KB_2files_0subdir': [1, 1, 1], + '1KB_0files_0subdir': [1, 1, 1] + }) + + @patch('listing_benchmark._record_time_of_operation', return_value=[1]) + def test_perform_testing_type3(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE3.folders, + 'fake_bucket', 'fake_disk', 2, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + '1KB_4files_3subdir': [1, 1], + '2KB_3files_1subdir': [1, 1], + '1KB_1files_0subdir': [1, 1] + }) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', + DIRECTORY_STRUCTURE1, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 1) + self.assertEqual(mock_generate_files.call_count, 0) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, []) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', + DIRECTORY_STRUCTURE2, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/2KB_3files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_2files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_0files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/', 1, 'kb', 1, + 'file', 'fake_disk_url/', True), + call('fake_bucket_url/2KB_3files_0subdir/', 3, 'kb', 2, + 'file', 'fake_disk_url/2KB_3files_0subdir/', True), + call('fake_bucket_url/1KB_2files_0subdir/', 2, 'kb', 1, + 'file', 'fake_disk_url/1KB_2files_0subdir/', True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', + DIRECTORY_STRUCTURE3, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 11) + self.assertEqual(mock_generate_files.call_count, 8) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/subsubdir1/', 2, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir2/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir2/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/subsubdir1/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, + 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=1) + def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', + DIRECTORY_STRUCTURE3, True) + self.assertTrue(exit_code > 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, + 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type1(self, mock_list): + mock_list.side_effect = [['fake_bucket/']] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE1) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + ['fake_bucket/1KB_0files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_folder_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/dummy_folder/', 'fake_bucket/2KB_3files_0subdir/file_1', + 'fake_bucket/2KB_3files_0subdir/file_2', 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type3(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/1KB_4files_3subdir/', + 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], + ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', + 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', 'fake_bucket/1KB_4files_3subdir/subdir3/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], + [], + ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], + ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], + ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], + ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', + 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], + [], + ['fake_bucket/1KB_1files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE3) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_folder_type3(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file1', 'fake_bucket/1KB_4files_3subdir/', + 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], + ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', + 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', 'fake_bucket/1KB_4files_3subdir/subdir3/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], + [], + ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], + ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], + ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], + ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', + 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], + ['fake_bucket/2KB_3files_1subdir/subdir1/file_1', + 'fake_bucket/2KB_3files_1subdir/subdir1/dummy_folder/'], + ['fake_bucket/1KB_1files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE3) + self.assertFalse(result) + + @patch('listing_benchmark.subprocess.call', return_value=0) + def test_unmount_gcs_bucket(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call( + 'umount -l fake_bucket', shell=True)) + self.assertEqual(mock_subprocess_call.call_args_list[1], call( + 'rm -rf fake_bucket', shell=True)) + + @patch('listing_benchmark.subprocess.call', return_value=1) + def test_unmount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call( + 'umount -l fake_bucket', shell=True)) + self.assertEqual( + mock_subprocess_call.call_args_list[1], call('bash', shell=True)) + + @patch('listing_benchmark.subprocess.call', return_value=0) + def test_mount_gcs_bucket(self, mock_subprocess_call): + directory_name = listing_benchmark._mount_gcs_bucket('fake_bucket') + self.assertEqual(directory_name, 'fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_bucket', shell=True), + call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=1) + def test_mount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._mount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_bucket', shell=True), + call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True), + call('bash', shell=True) + ]) - self.assertEqual(metrics, - { - '2KB_3files_0subdir': - { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 0.517818, - 'Median': 0.222, - 'Standard Dev': 0.5559497869592182, - 'Quantiles': - { - '0 %ile': 0.01709, - '20 %ile': 0.100218, - '40 %ile': 0.1816, - '60 %ile': 0.5311999999999999, - '80 %ile': 1.0428, - '90 %ile': 1.1384, - '95 %ile': 1.1862, - '98 %ile': 1.21488, - '99 %ile': 1.22444, - '100 %ile': 1.234 - } - }, - '1KB_2files_0subdir': - { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 19.965, - 'Median': 1.95, - 'Standard Dev': 39.504362202166995, - 'Quantiles': - { - '0 %ile': 0.001, - '20 %ile': 0.2674, - '40 %ile': 1.3036, - '60 %ile': 4.005999999999999, - '80 %ile': 23.762000000000015, - '90 %ile': 57.10600000000001, - '95 %ile': 73.77799999999999, - '98 %ile': 83.7812, - '99 %ile': 87.1156, - '100 %ile': 90.45 - } - }, - '1KB_0files_0subdir': - { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 37, - 'Median': 21, - 'Standard Dev': 39.62953444086872, - 'Quantiles': - { - '0 %ile': 6.0, - '20 %ile': 6.8, - '40 %ile': 15.400000000000002, - '60 %ile': 33.0, - '80 %ile': 60.80000000000001, - '90 %ile': 80.4, - '95 %ile': 90.19999999999999, - '98 %ile': 96.08, - '99 %ile': 98.03999999999999, - '100 %ile': 100.0 - } - } - } - ) - - @patch("listing_benchmark.subprocess.call", return_value = 1) - @patch("listing_benchmark.time.time", return_value = 1) - def test_record_time_of_operation(self, mock_time, mock_subprocess_call): - result_list = listing_benchmark._record_time_of_operation("ls", "fakepath/", 5) - self.assertEqual(mock_subprocess_call.call_count, 5) - self.assertEqual(result_list, [0, 0, 0, 0, 0]) - - @patch("listing_benchmark._record_time_of_operation") - def test_perform_testing_type1(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE1.folders, - "fake_bucket", "fake_disk", 3, "ls -R") - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertFalse(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, {}) - - @patch("listing_benchmark._record_time_of_operation") - def test_perform_testing_type2(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE2.folders, - "fake_bucket", "fake_disk", 3, "ls -R") - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertTrue(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, { - "2KB_3files_0subdir": [1, 1, 1], - "1KB_2files_0subdir": [1, 1, 1], - "1KB_0files_0subdir": [1, 1, 1] - }) - - @patch("listing_benchmark._record_time_of_operation", return_value = [1]) - def test_perform_testing_type3(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE3.folders, - "fake_bucket", "fake_disk", 2, "ls -R") - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertTrue(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, { - "1KB_4files_3subdir": [1, 1], - "2KB_3files_1subdir": [1, 1], - "1KB_1files_0subdir": [1, 1] - }) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) - def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", - DIRECTORY_STRUCTURE1, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 1) - self.assertEqual(mock_generate_files.call_count, 0) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, []) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) - def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", - DIRECTORY_STRUCTURE2, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 4) - self.assertEqual(mock_generate_files.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/2KB_3files_0subdir/', shell=True), - call('mkdir fake_disk_url/1KB_2files_0subdir/', shell=True), - call('mkdir fake_disk_url/1KB_0files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/', 1, 'kb', 1, 'file', 'fake_disk_url/', True), - call('fake_bucket_url/2KB_3files_0subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_0subdir/', True), - call('fake_bucket_url/1KB_2files_0subdir/', 2, 'kb', 1, 'file', 'fake_disk_url/1KB_2files_0subdir/', True) - ]) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 0) - def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", - DIRECTORY_STRUCTURE3, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 11) - self.assertEqual(mock_generate_files.call_count, 8) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir2/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir2/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/subdir1/', shell=True), - call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir1/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir1/subsubdir1/', 2, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir2/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir2/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir3/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir3/subsubdir1/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', True), - call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_1subdir/', True), - call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_1files_0subdir/', True) - ]) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - @patch("listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket", return_value = 1) - def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure("fake_bucket_url/", "fake_disk_url/", - DIRECTORY_STRUCTURE3, True) - self.assertTrue(exit_code > 0) - self.assertEqual(mock_subprocess_call.call_count, 4) - self.assertEqual(mock_generate_files.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), - call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, 'file', 'fake_disk_url/1KB_4files_3subdir/', True), - call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, 'file', 'fake_disk_url/2KB_3files_1subdir/', True), - call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, 'file', 'fake_disk_url/1KB_1files_0subdir/', True) - ]) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_true_type1(self, mock_list): - mock_list.side_effect = [["fake_bucket/"]] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE1) - self.assertTrue(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_true_type2(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], - ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], - ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], - [] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) - self.assertTrue(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_false_file_type2(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], - ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], - ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], - ["fake_bucket/1KB_0files_0subdir/file_1"] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_false_folder_type2(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/file", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], - ["fake_bucket/2KB_3files_0subdir/dummy_folder/", "fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], - ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], - [] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_false_file_type2(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/2KB_3files_0subdir/", "fake_bucket/1KB_2files_0subdir/", "fake_bucket/1KB_0files_0subdir/"], - ["fake_bucket/2KB_3files_0subdir/file_1", "fake_bucket/2KB_3files_0subdir/file_2", "fake_bucket/2KB_3files_0subdir/file_3"], - ["fake_bucket/1KB_2files_0subdir/file_1", "fake_bucket/1KB_2files_0subdir/file_2"], - [] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_true_type3(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/1KB_4files_3subdir/", "fake_bucket/2KB_3files_1subdir/", "fake_bucket/1KB_1files_0subdir/"], - ["fake_bucket/1KB_4files_3subdir/file_1", "fake_bucket/1KB_4files_3subdir/file_2", "fake_bucket/1KB_4files_3subdir/file_3", "fake_bucket/1KB_4files_3subdir/file_4", - "fake_bucket/1KB_4files_3subdir/subdir1/", "fake_bucket/1KB_4files_3subdir/subdir2/", "fake_bucket/1KB_4files_3subdir/subdir3/"], - ["fake_bucket/1KB_4files_3subdir/subdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/"], - ["fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2"], - [], - ["fake_bucket/1KB_4files_3subdir/subdir2/file_1"], - ["fake_bucket/1KB_4files_3subdir/subdir3/file_1", "fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/"], - ["fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1"], - ["fake_bucket/2KB_3files_1subdir/file_1", "fake_bucket/2KB_3files_1subdir/file_2", "fake_bucket/2KB_3files_1subdir/file_3", "fake_bucket/2KB_3files_1subdir/subdir1/"], - [], - ["fake_bucket/1KB_1files_0subdir/file_1"] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE3) - self.assertTrue(result) - - @patch("listing_benchmark._list_directory") - def test_compare_directory_structure_false_file_folder_type3(self, mock_list): - mock_list.side_effect = [ - ["fake_bucket/", "fake_bucket/file1", "fake_bucket/1KB_4files_3subdir/", "fake_bucket/2KB_3files_1subdir/", "fake_bucket/1KB_1files_0subdir/"], - ["fake_bucket/1KB_4files_3subdir/file_1", "fake_bucket/1KB_4files_3subdir/file_2", "fake_bucket/1KB_4files_3subdir/file_3", "fake_bucket/1KB_4files_3subdir/file_4", - "fake_bucket/1KB_4files_3subdir/subdir1/", "fake_bucket/1KB_4files_3subdir/subdir2/", "fake_bucket/1KB_4files_3subdir/subdir3/"], - ["fake_bucket/1KB_4files_3subdir/subdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/"], - ["fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1", "fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2"], - [], - ["fake_bucket/1KB_4files_3subdir/subdir2/file_1"], - ["fake_bucket/1KB_4files_3subdir/subdir3/file_1", "fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/"], - ["fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1"], - ["fake_bucket/2KB_3files_1subdir/file_1", "fake_bucket/2KB_3files_1subdir/file_2", "fake_bucket/2KB_3files_1subdir/file_3", "fake_bucket/2KB_3files_1subdir/subdir1/"], - ["fake_bucket/2KB_3files_1subdir/subdir1/file_1", "fake_bucket/2KB_3files_1subdir/subdir1/dummy_folder/"], - ["fake_bucket/1KB_1files_0subdir/file_1"] - ] - result = listing_benchmark._compare_directory_structure("fake_bucket/", DIRECTORY_STRUCTURE3) - self.assertFalse(result) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - def test_unmount_gcs_bucket(self, mock_subprocess_call): - listing_benchmark._unmount_gcs_bucket("fake_bucket") - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list[0], call("umount -l fake_bucket", shell=True)) - self.assertEqual(mock_subprocess_call.call_args_list[1], call("rm -rf fake_bucket", shell=True)) - - @patch("listing_benchmark.subprocess.call", return_value = 1) - def test_unmount_gcs_bucket_error(self, mock_subprocess_call): - listing_benchmark._unmount_gcs_bucket("fake_bucket") - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list[0], call("umount -l fake_bucket", shell=True)) - self.assertEqual(mock_subprocess_call.call_args_list[1], call("bash", shell=True)) - - @patch("listing_benchmark.subprocess.call", return_value = 0) - def test_mount_gcs_bucket(self, mock_subprocess_call): - directory_name = listing_benchmark._mount_gcs_bucket("fake_bucket") - self.assertEqual(directory_name, "fake_bucket") - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call("mkdir fake_bucket", shell=True), - call("gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket", shell=True) - ]) - - @patch("listing_benchmark.subprocess.call", return_value = 1) - def test_mount_gcs_bucket_error(self, mock_subprocess_call): - listing_benchmark._mount_gcs_bucket("fake_bucket") - self.assertEqual(mock_subprocess_call.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call("mkdir fake_bucket", shell=True), - call("gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket", shell=True), - call("bash", shell=True) - ]) if __name__ == '__main__': - unittest.main() + unittest.main() From fb51f143d4383673fa95c4589dd5d83cc9fa1b42 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Tue, 2 Aug 2022 18:28:06 +0000 Subject: [PATCH 4/7] added a test for record time operation. --- perfmetrics/scripts/ls_metrics/listing_benchmark_test.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index 5f579162f6..e62aaa9b9d 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -215,6 +215,15 @@ def test_record_time_of_operation(self, mock_time, mock_subprocess_call): self.assertEqual(mock_subprocess_call.call_count, 5) self.assertEqual(result_list, [0, 0, 0, 0, 0]) + @patch('listing_benchmark.subprocess.call', return_value=1) + @patch('listing_benchmark.time.time') + def test_record_time_of_operation_different_time(self, mock_time, mock_subprocess_call): + mock_time.side_effect = [1, 2, 3, 5] + result_list = listing_benchmark._record_time_of_operation( + 'ls', 'fakepath/', 2) + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(result_list, [1000, 2000]) + @patch('listing_benchmark._record_time_of_operation') def test_perform_testing_type1(self, mock_record_time_of_operation): mock_record_time_of_operation.return_value = [1, 1, 1] From 36e46d0a0e7f356f4271b53b5a7cc4664a67e0af Mon Sep 17 00:00:00 2001 From: Pranjal Date: Wed, 3 Aug 2022 08:23:59 +0000 Subject: [PATCH 5/7] formatted the code. --- .../scripts/ls_metrics/listing_benchmark.py | 2 +- .../ls_metrics/listing_benchmark_test.py | 922 +++++++++--------- 2 files changed, 464 insertions(+), 460 deletions(-) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark.py b/perfmetrics/scripts/ls_metrics/listing_benchmark.py index b697b1a521..aa75708f71 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark.py @@ -201,7 +201,7 @@ def _create_directory_structure(gcs_bucket_url, persistent_disk_url, directory_s def _list_directory(path) -> list: - """Returns the list containing path of all the contents present in the current directory and also the number of contents. + """Returns the list containing path of all the contents present in the current directory. Args: path: Path of the directory. diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index e62aaa9b9d..3fb7c4e7c2 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -1,11 +1,12 @@ """Tests for listing_benchmark.""" -import listing_benchmark import unittest from unittest import mock -from mock import patch, call + import directory_pb2 as directory_proto -from google.protobuf.json_format import Parse, ParseDict +from google.protobuf.json_format import ParseDict +import listing_benchmark +from mock import patch, call # (Type 1) - 0 levels deep directory structure. DIRECTORY_STRUCTURE1 = { @@ -20,21 +21,21 @@ 'file_size': '1kb', 'file_name_prefix': 'file', 'folders': [ - { - 'name': '2KB_3files_0subdir', - 'num_files': 3, - 'file_name_prefix': 'file', - 'file_size': '2kb' - }, { - 'name': '1KB_2files_0subdir', - 'num_files': 2, - 'file_size': '1kb', - 'file_name_prefix': 'file' - }, + 'name': '2KB_3files_0subdir', + 'num_files': 3, + 'file_name_prefix': 'file', + 'file_size': '2kb' + }, + { + 'name': '1KB_2files_0subdir', + 'num_files': 2, + 'file_size': '1kb', + 'file_name_prefix': 'file' + }, { - 'name': '1KB_0files_0subdir' - } + 'name': '1KB_0files_0subdir' + } ] } @@ -44,79 +45,81 @@ 'num_folders': 3, 'num_files': 0, 'folders': [ - { - 'name': '1KB_4files_3subdir', - 'num_files': 4, - 'file_name_prefix': 'file', - 'file_size': '1kb', - 'num_folders': 3, - 'folders': [ - { - 'name': 'subdir1', - 'num_files': 1, - 'file_name_prefix': 'file', - 'file_size': '1kb', - 'num_folders': 2, - 'folders': [ - { - 'name': 'subsubdir1', - 'num_files': 2, - 'file_name_prefix': 'file', - 'file_size': '1kb' - }, - { - 'name': 'subsubdir2' - } - ] - }, - { - 'name': 'subdir2', - 'num_files': 1, - 'file_name_prefix': 'file', - 'file_size': '1kb' - }, - { - 'name': 'subdir3', - 'num_files': 1, - 'file_name_prefix': 'file', - 'file_size': '1kb', - 'num_folders': 1, - 'folders': [ - { - 'name': 'subsubdir1', - 'num_files': 1, - 'file_name_prefix': 'file', - 'file_size': '1kb' - } - ] - } - ] - }, { - 'name': '2KB_3files_1subdir', - 'num_files': 3, - 'file_name_prefix': 'file', - 'file_size': '2kb', - 'num_folders': 1, - 'folders': [ - { - 'name': 'subdir1' - } - ] + 'name': '1KB_4files_3subdir', + 'num_files': 4, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 3, + 'folders': [ + { + 'name': 'subdir1', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 2, + 'folders': [ + { + 'name': 'subsubdir1', + 'num_files': 2, + 'file_name_prefix': 'file', + 'file_size': '1kb' + }, + { + 'name': 'subsubdir2' + } + ] }, + { + 'name': 'subdir2', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb' + }, + { + 'name': 'subdir3', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb', + 'num_folders': 1, + 'folders': [ + { + 'name': 'subsubdir1', + 'num_files': 1, + 'file_name_prefix': 'file', + 'file_size': '1kb' + } + ] + } + ] + }, { - 'name': '1KB_1files_0subdir', - 'num_files': 1, - 'file_size': '1kb', - 'file_name_prefix': 'file' + 'name': '2KB_3files_1subdir', + 'num_files': 3, + 'file_name_prefix': 'file', + 'file_size': '2kb', + 'num_folders': 1, + 'folders': [ + { + 'name': 'subdir1' } + ] + }, + { + 'name': '1KB_1files_0subdir', + 'num_files': 1, + 'file_size': '1kb', + 'file_name_prefix': 'file' + } ] } +# List of latencies (msec) of list operation to test _parse_results method. METRICS1 = [1.234, 0.995, 0.121, 0.222, 0.01709] METRICS2 = [90.45, 1.95, 0.334, 7.090, 0.001] METRICS3 = [100, 7, 6, 51, 21] +# Converting JSON to protobuf. DIRECTORY_STRUCTURE1 = ParseDict( DIRECTORY_STRUCTURE1, directory_proto.Directory()) DIRECTORY_STRUCTURE2 = ParseDict( @@ -127,393 +130,394 @@ class ListingBenchmarkTest(unittest.TestCase): - def test_parse_results_type1(self): - metrics = listing_benchmark._parse_results( - DIRECTORY_STRUCTURE1.folders, {}, 'fake_test', 5) - self.assertEqual(metrics, {}) - - def test_parse_results_type2(self): - metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { - '2KB_3files_0subdir': METRICS1, - '1KB_2files_0subdir': METRICS2, - '1KB_0files_0subdir': METRICS3 - }, 'fake_test', 5) - - self.assertEqual(metrics, + def test_parse_results_type1(self): + metrics = listing_benchmark._parse_results( + DIRECTORY_STRUCTURE1.folders, {}, 'fake_test', 5) + self.assertEqual(metrics, {}) + + def test_parse_results_type2(self): + metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { + '2KB_3files_0subdir': METRICS1, + '1KB_2files_0subdir': METRICS2, + '1KB_0files_0subdir': METRICS3 + }, 'fake_test', 5) + self.assertEqual(metrics, + { + '2KB_3files_0subdir': { - '2KB_3files_0subdir': + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 0.517818, + 'Median': 0.222, + 'Standard Dev': 0.5559497869592182, + 'Quantiles': { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 0.517818, - 'Median': 0.222, - 'Standard Dev': 0.5559497869592182, - 'Quantiles': - { - '0 %ile': 0.01709, - '20 %ile': 0.100218, - '40 %ile': 0.1816, - '60 %ile': 0.5311999999999999, - '80 %ile': 1.0428, - '90 %ile': 1.1384, - '95 %ile': 1.1862, - '98 %ile': 1.21488, - '99 %ile': 1.22444, - '100 %ile': 1.234 - } - }, - '1KB_2files_0subdir': + '0 %ile': 0.01709, + '20 %ile': 0.100218, + '40 %ile': 0.1816, + '60 %ile': 0.5311999999999999, + '80 %ile': 1.0428, + '90 %ile': 1.1384, + '95 %ile': 1.1862, + '98 %ile': 1.21488, + '99 %ile': 1.22444, + '100 %ile': 1.234 + } + }, + '1KB_2files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 19.965, + 'Median': 1.95, + 'Standard Dev': 39.504362202166995, + 'Quantiles': { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 19.965, - 'Median': 1.95, - 'Standard Dev': 39.504362202166995, - 'Quantiles': - { - '0 %ile': 0.001, - '20 %ile': 0.2674, - '40 %ile': 1.3036, - '60 %ile': 4.005999999999999, - '80 %ile': 23.762000000000015, - '90 %ile': 57.10600000000001, - '95 %ile': 73.77799999999999, - '98 %ile': 83.7812, - '99 %ile': 87.1156, - '100 %ile': 90.45 - } - }, - '1KB_0files_0subdir': + '0 %ile': 0.001, + '20 %ile': 0.2674, + '40 %ile': 1.3036, + '60 %ile': 4.005999999999999, + '80 %ile': 23.762000000000015, + '90 %ile': 57.10600000000001, + '95 %ile': 73.77799999999999, + '98 %ile': 83.7812, + '99 %ile': 87.1156, + '100 %ile': 90.45 + } + }, + '1KB_0files_0subdir': + { + 'Test Desc.': 'fake_test', + 'Number of samples': 5, + 'Mean': 37, + 'Median': 21, + 'Standard Dev': 39.62953444086872, + 'Quantiles': { - 'Test Desc.': 'fake_test', - 'Number of samples': 5, - 'Mean': 37, - 'Median': 21, - 'Standard Dev': 39.62953444086872, - 'Quantiles': - { - '0 %ile': 6.0, - '20 %ile': 6.8, - '40 %ile': 15.400000000000002, - '60 %ile': 33.0, - '80 %ile': 60.80000000000001, - '90 %ile': 80.4, - '95 %ile': 90.19999999999999, - '98 %ile': 96.08, - '99 %ile': 98.03999999999999, - '100 %ile': 100.0 - } + '0 %ile': 6.0, + '20 %ile': 6.8, + '40 %ile': 15.400000000000002, + '60 %ile': 33.0, + '80 %ile': 60.80000000000001, + '90 %ile': 80.4, + '95 %ile': 90.19999999999999, + '98 %ile': 96.08, + '99 %ile': 98.03999999999999, + '100 %ile': 100.0 } } - ) - - @patch('listing_benchmark.subprocess.call', return_value=1) - @patch('listing_benchmark.time.time', return_value=1) - def test_record_time_of_operation(self, mock_time, mock_subprocess_call): - result_list = listing_benchmark._record_time_of_operation( - 'ls', 'fakepath/', 5) - self.assertEqual(mock_subprocess_call.call_count, 5) - self.assertEqual(result_list, [0, 0, 0, 0, 0]) - - @patch('listing_benchmark.subprocess.call', return_value=1) - @patch('listing_benchmark.time.time') - def test_record_time_of_operation_different_time(self, mock_time, mock_subprocess_call): - mock_time.side_effect = [1, 2, 3, 5] - result_list = listing_benchmark._record_time_of_operation( - 'ls', 'fakepath/', 2) - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(result_list, [1000, 2000]) - - @patch('listing_benchmark._record_time_of_operation') - def test_perform_testing_type1(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE1.folders, - 'fake_bucket', 'fake_disk', 3, 'ls -R') - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertFalse(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, {}) - - @patch('listing_benchmark._record_time_of_operation') - def test_perform_testing_type2(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE2.folders, - 'fake_bucket', 'fake_disk', 3, 'ls -R') - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertTrue(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, { - '2KB_3files_0subdir': [1, 1, 1], - '1KB_2files_0subdir': [1, 1, 1], - '1KB_0files_0subdir': [1, 1, 1] - }) - - @patch('listing_benchmark._record_time_of_operation', return_value=[1]) - def test_perform_testing_type3(self, mock_record_time_of_operation): - mock_record_time_of_operation.return_value = [1, 1] - gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing(DIRECTORY_STRUCTURE3.folders, - 'fake_bucket', 'fake_disk', 2, 'ls -R') - self.assertEqual(gcs_bucket_results, persistent_disk_results) - self.assertTrue(mock_record_time_of_operation.called) - self.assertEqual(gcs_bucket_results, { - '1KB_4files_3subdir': [1, 1], - '2KB_3files_1subdir': [1, 1], - '1KB_1files_0subdir': [1, 1] - }) - - @patch('listing_benchmark.subprocess.call', return_value=0) - @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', - DIRECTORY_STRUCTURE1, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 1) - self.assertEqual(mock_generate_files.call_count, 0) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, []) - - @patch('listing_benchmark.subprocess.call', return_value=0) - @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', - DIRECTORY_STRUCTURE2, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 4) - self.assertEqual(mock_generate_files.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/2KB_3files_0subdir/', shell=True), - call('mkdir fake_disk_url/1KB_2files_0subdir/', shell=True), - call('mkdir fake_disk_url/1KB_0files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/', 1, 'kb', 1, - 'file', 'fake_disk_url/', True), - call('fake_bucket_url/2KB_3files_0subdir/', 3, 'kb', 2, - 'file', 'fake_disk_url/2KB_3files_0subdir/', True), - call('fake_bucket_url/1KB_2files_0subdir/', 2, 'kb', 1, - 'file', 'fake_disk_url/1KB_2files_0subdir/', True) - ]) - - @patch('listing_benchmark.subprocess.call', return_value=0) - @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', - DIRECTORY_STRUCTURE3, True) - self.assertEqual(exit_code, 0) - self.assertEqual(mock_subprocess_call.call_count, 11) - self.assertEqual(mock_generate_files.call_count, 8) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir2/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir2/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/subdir1/', shell=True), - call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir1/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir1/subsubdir1/', 2, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir2/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/subdir2/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir3/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/', True), - call('fake_bucket_url/1KB_4files_3subdir/subdir3/subsubdir1/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', True), - call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, - 'file', 'fake_disk_url/2KB_3files_1subdir/', True), - call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_1files_0subdir/', True) - ]) - - @patch('listing_benchmark.subprocess.call', return_value=0) - @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=1) - def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): - exit_code = listing_benchmark._create_directory_structure('fake_bucket_url/', 'fake_disk_url/', - DIRECTORY_STRUCTURE3, True) - self.assertTrue(exit_code > 0) - self.assertEqual(mock_subprocess_call.call_count, 4) - self.assertEqual(mock_generate_files.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_disk_url/', shell=True), - call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), - call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), - call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) - ]) - self.assertEqual(mock_generate_files.call_args_list, [ - call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, - 'file', 'fake_disk_url/1KB_4files_3subdir/', True), - call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, - 'file', 'fake_disk_url/2KB_3files_1subdir/', True), - call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, - 'file', 'fake_disk_url/1KB_1files_0subdir/', True) - ]) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type1(self, mock_list): - mock_list.side_effect = [['fake_bucket/']] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE1) - self.assertTrue(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type2(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', - 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], - ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', - 'fake_bucket/2KB_3files_0subdir/file_3'], - ['fake_bucket/1KB_2files_0subdir/file_1', - 'fake_bucket/1KB_2files_0subdir/file_2'], - [] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE2) - self.assertTrue(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_type2(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', - 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], - ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', - 'fake_bucket/2KB_3files_0subdir/file_3'], - ['fake_bucket/1KB_2files_0subdir/file_1', - 'fake_bucket/1KB_2files_0subdir/file_2'], - ['fake_bucket/1KB_0files_0subdir/file_1'] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_folder_type2(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', - 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], - ['fake_bucket/2KB_3files_0subdir/dummy_folder/', 'fake_bucket/2KB_3files_0subdir/file_1', - 'fake_bucket/2KB_3files_0subdir/file_2', 'fake_bucket/2KB_3files_0subdir/file_3'], - ['fake_bucket/1KB_2files_0subdir/file_1', - 'fake_bucket/1KB_2files_0subdir/file_2'], - [] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_type2(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/2KB_3files_0subdir/', - 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], - ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', - 'fake_bucket/2KB_3files_0subdir/file_3'], - ['fake_bucket/1KB_2files_0subdir/file_1', - 'fake_bucket/1KB_2files_0subdir/file_2'], - [] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE2) - self.assertFalse(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type3(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/1KB_4files_3subdir/', - 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], - ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', - 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', 'fake_bucket/1KB_4files_3subdir/subdir3/'], - ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', - 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], - ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', - 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], - [], - ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], - ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', - 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], - ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], - ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', - 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], - [], - ['fake_bucket/1KB_1files_0subdir/file_1'] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE3) - self.assertTrue(result) - - @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_folder_type3(self, mock_list): - mock_list.side_effect = [ - ['fake_bucket/', 'fake_bucket/file1', 'fake_bucket/1KB_4files_3subdir/', - 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], - ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', - 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', 'fake_bucket/1KB_4files_3subdir/subdir3/'], - ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', - 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], - ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', - 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], - [], - ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], - ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', - 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], - ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], - ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', - 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], - ['fake_bucket/2KB_3files_1subdir/subdir1/file_1', - 'fake_bucket/2KB_3files_1subdir/subdir1/dummy_folder/'], - ['fake_bucket/1KB_1files_0subdir/file_1'] - ] - result = listing_benchmark._compare_directory_structure( - 'fake_bucket/', DIRECTORY_STRUCTURE3) - self.assertFalse(result) - - @patch('listing_benchmark.subprocess.call', return_value=0) - def test_unmount_gcs_bucket(self, mock_subprocess_call): - listing_benchmark._unmount_gcs_bucket('fake_bucket') - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list[0], call( - 'umount -l fake_bucket', shell=True)) - self.assertEqual(mock_subprocess_call.call_args_list[1], call( - 'rm -rf fake_bucket', shell=True)) - - @patch('listing_benchmark.subprocess.call', return_value=1) - def test_unmount_gcs_bucket_error(self, mock_subprocess_call): - listing_benchmark._unmount_gcs_bucket('fake_bucket') - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list[0], call( - 'umount -l fake_bucket', shell=True)) - self.assertEqual( - mock_subprocess_call.call_args_list[1], call('bash', shell=True)) - - @patch('listing_benchmark.subprocess.call', return_value=0) - def test_mount_gcs_bucket(self, mock_subprocess_call): - directory_name = listing_benchmark._mount_gcs_bucket('fake_bucket') - self.assertEqual(directory_name, 'fake_bucket') - self.assertEqual(mock_subprocess_call.call_count, 2) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_bucket', shell=True), - call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True) - ]) - - @patch('listing_benchmark.subprocess.call', return_value=1) - def test_mount_gcs_bucket_error(self, mock_subprocess_call): - listing_benchmark._mount_gcs_bucket('fake_bucket') - self.assertEqual(mock_subprocess_call.call_count, 3) - self.assertEqual(mock_subprocess_call.call_args_list, [ - call('mkdir fake_bucket', shell=True), - call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True), - call('bash', shell=True) - ]) + } + ) + + @patch('listing_benchmark.subprocess.call', return_value=1) + @patch('listing_benchmark.time.time', return_value=1) + def test_record_time_of_operation(self, mock_time, mock_subprocess_call): + result_list = listing_benchmark._record_time_of_operation('ls', 'fakepath/', 5) + self.assertEqual(mock_subprocess_call.call_count, 5) + self.assertEqual(result_list, [0, 0, 0, 0, 0]) + + @patch('listing_benchmark.subprocess.call', return_value=1) + @patch('listing_benchmark.time.time') + def test_record_time_of_operation_different_time(self, mock_time, mock_subprocess_call): + mock_time.side_effect = [1, 2, 3, 5] + result_list = listing_benchmark._record_time_of_operation('ls', 'fakepath/', 2) + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(result_list, [1000, 2000]) + + @patch('listing_benchmark._record_time_of_operation') + def test_perform_testing_type1(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( + DIRECTORY_STRUCTURE1.folders, 'fake_bucket', 'fake_disk', 3, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertFalse(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, {}) + + @patch('listing_benchmark._record_time_of_operation') + def test_perform_testing_type2(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( + DIRECTORY_STRUCTURE2.folders, 'fake_bucket', 'fake_disk', 3, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + '2KB_3files_0subdir': [1, 1, 1], + '1KB_2files_0subdir': [1, 1, 1], + '1KB_0files_0subdir': [1, 1, 1] + }) + + @patch('listing_benchmark._record_time_of_operation', return_value=[1]) + def test_perform_testing_type3(self, mock_record_time_of_operation): + mock_record_time_of_operation.return_value = [1, 1] + gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( + DIRECTORY_STRUCTURE3.folders, 'fake_bucket', 'fake_disk', 2, 'ls -R') + self.assertEqual(gcs_bucket_results, persistent_disk_results) + self.assertTrue(mock_record_time_of_operation.called) + self.assertEqual(gcs_bucket_results, { + '1KB_4files_3subdir': [1, 1], + '2KB_3files_1subdir': [1, 1], + '1KB_1files_0subdir': [1, 1] + }) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure( + 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE1, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 1) + self.assertEqual(mock_generate_files.call_count, 0) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, []) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure( + 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE2, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/2KB_3files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_2files_0subdir/', shell=True), + call('mkdir fake_disk_url/1KB_0files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/', 1, 'kb', 1, 'file', 'fake_disk_url/', True), + call('fake_bucket_url/2KB_3files_0subdir/', 3, 'kb', 2, 'file', + 'fake_disk_url/2KB_3files_0subdir/', True), + call('fake_bucket_url/1KB_2files_0subdir/', 2, 'kb', 1, 'file', + 'fake_disk_url/1KB_2files_0subdir/', True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) + def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure( + 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE3, True) + self.assertEqual(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 11) + self.assertEqual(mock_generate_files.call_count, 8) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir2/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/subdir1/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir1/subsubdir1/', 2, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir1/subsubdir1/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir2/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir2/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/', True), + call('fake_bucket_url/1KB_4files_3subdir/subdir3/subsubdir1/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/subdir3/subsubdir1/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, + 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=0) + @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=1) + def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): + exit_code = listing_benchmark._create_directory_structure( + 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE3, True) + self.assertGreater(exit_code, 0) + self.assertEqual(mock_subprocess_call.call_count, 4) + self.assertEqual(mock_generate_files.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_disk_url/', shell=True), + call('mkdir fake_disk_url/1KB_4files_3subdir/', shell=True), + call('mkdir fake_disk_url/2KB_3files_1subdir/', shell=True), + call('mkdir fake_disk_url/1KB_1files_0subdir/', shell=True) + ]) + self.assertEqual(mock_generate_files.call_args_list, [ + call('fake_bucket_url/1KB_4files_3subdir/', 4, 'kb', 1, + 'file', 'fake_disk_url/1KB_4files_3subdir/', True), + call('fake_bucket_url/2KB_3files_1subdir/', 3, 'kb', 2, + 'file', 'fake_disk_url/2KB_3files_1subdir/', True), + call('fake_bucket_url/1KB_1files_0subdir/', 1, 'kb', 1, + 'file', 'fake_disk_url/1KB_1files_0subdir/', True) + ]) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type1(self, mock_list): + mock_list.side_effect = [['fake_bucket/']] + result = listing_benchmark._compare_directory_structure('fake_bucket/', DIRECTORY_STRUCTURE1) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + ['fake_bucket/1KB_0files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_folder_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/dummy_folder/', 'fake_bucket/2KB_3files_0subdir/file_1', + 'fake_bucket/2KB_3files_0subdir/file_2', 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_type2(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/2KB_3files_0subdir/', + 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], + ['fake_bucket/2KB_3files_0subdir/file_1', 'fake_bucket/2KB_3files_0subdir/file_2', + 'fake_bucket/2KB_3files_0subdir/file_3'], + ['fake_bucket/1KB_2files_0subdir/file_1', + 'fake_bucket/1KB_2files_0subdir/file_2'], + [] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE2) + self.assertFalse(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_true_type3(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/1KB_4files_3subdir/', + 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], + ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', + 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', + 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', + 'fake_bucket/1KB_4files_3subdir/subdir3/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], + [], + ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], + ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], + ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], + ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', + 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], + [], + ['fake_bucket/1KB_1files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE3) + self.assertTrue(result) + + @patch('listing_benchmark._list_directory') + def test_compare_directory_structure_false_file_folder_type3(self, mock_list): + mock_list.side_effect = [ + ['fake_bucket/', 'fake_bucket/file1', 'fake_bucket/1KB_4files_3subdir/', + 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], + ['fake_bucket/1KB_4files_3subdir/file_1', 'fake_bucket/1KB_4files_3subdir/file_2', + 'fake_bucket/1KB_4files_3subdir/file_3', 'fake_bucket/1KB_4files_3subdir/file_4', + 'fake_bucket/1KB_4files_3subdir/subdir1/', 'fake_bucket/1KB_4files_3subdir/subdir2/', + 'fake_bucket/1KB_4files_3subdir/subdir3/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir2/'], + ['fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir1/subsubdir1/file_2'], + [], + ['fake_bucket/1KB_4files_3subdir/subdir2/file_1'], + ['fake_bucket/1KB_4files_3subdir/subdir3/file_1', + 'fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/'], + ['fake_bucket/1KB_4files_3subdir/subdir3/subsubdir1/file_1'], + ['fake_bucket/2KB_3files_1subdir/file_1', 'fake_bucket/2KB_3files_1subdir/file_2', + 'fake_bucket/2KB_3files_1subdir/file_3', 'fake_bucket/2KB_3files_1subdir/subdir1/'], + ['fake_bucket/2KB_3files_1subdir/subdir1/file_1', + 'fake_bucket/2KB_3files_1subdir/subdir1/dummy_folder/'], + ['fake_bucket/1KB_1files_0subdir/file_1'] + ] + result = listing_benchmark._compare_directory_structure( + 'fake_bucket/', DIRECTORY_STRUCTURE3) + self.assertFalse(result) + + @patch('listing_benchmark.subprocess.call', return_value=0) + def test_unmount_gcs_bucket(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call( + 'umount -l fake_bucket', shell=True)) + self.assertEqual(mock_subprocess_call.call_args_list[1], call( + 'rm -rf fake_bucket', shell=True)) + + @patch('listing_benchmark.subprocess.call', return_value=1) + def test_unmount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._unmount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list[0], call( + 'umount -l fake_bucket', shell=True)) + self.assertEqual( + mock_subprocess_call.call_args_list[1], call('bash', shell=True)) + + @patch('listing_benchmark.subprocess.call', return_value=0) + def test_mount_gcs_bucket(self, mock_subprocess_call): + directory_name = listing_benchmark._mount_gcs_bucket('fake_bucket') + self.assertEqual(directory_name, 'fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 2) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_bucket', shell=True), + call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True) + ]) + + @patch('listing_benchmark.subprocess.call', return_value=1) + def test_mount_gcs_bucket_error(self, mock_subprocess_call): + listing_benchmark._mount_gcs_bucket('fake_bucket') + self.assertEqual(mock_subprocess_call.call_count, 3) + self.assertEqual(mock_subprocess_call.call_args_list, [ + call('mkdir fake_bucket', shell=True), + call('gcsfuse --implicit-dirs --disable-http2 --max-conns-per-host 100 fake_bucket fake_bucket', shell=True), + call('bash', shell=True) + ]) if __name__ == '__main__': - unittest.main() + unittest.main() From 5eb90f0c5fc414867e7722f2ca67e59a69fcf146 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Wed, 3 Aug 2022 08:42:02 +0000 Subject: [PATCH 6/7] formatted the name of methods. --- .../ls_metrics/listing_benchmark_test.py | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index 3fb7c4e7c2..a205ae9520 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -130,12 +130,12 @@ class ListingBenchmarkTest(unittest.TestCase): - def test_parse_results_type1(self): + def test_parse_results_single_level_dir(self): metrics = listing_benchmark._parse_results( DIRECTORY_STRUCTURE1.folders, {}, 'fake_test', 5) self.assertEqual(metrics, {}) - def test_parse_results_type2(self): + def test_parse_results_double_level_dir(self): metrics = listing_benchmark._parse_results(DIRECTORY_STRUCTURE2.folders, { '2KB_3files_0subdir': METRICS1, '1KB_2files_0subdir': METRICS2, @@ -211,7 +211,7 @@ def test_parse_results_type2(self): @patch('listing_benchmark.subprocess.call', return_value=1) @patch('listing_benchmark.time.time', return_value=1) - def test_record_time_of_operation(self, mock_time, mock_subprocess_call): + def test_record_time_of_operation_same_time(self, mock_time, mock_subprocess_call): result_list = listing_benchmark._record_time_of_operation('ls', 'fakepath/', 5) self.assertEqual(mock_subprocess_call.call_count, 5) self.assertEqual(result_list, [0, 0, 0, 0, 0]) @@ -225,7 +225,7 @@ def test_record_time_of_operation_different_time(self, mock_time, mock_subproces self.assertEqual(result_list, [1000, 2000]) @patch('listing_benchmark._record_time_of_operation') - def test_perform_testing_type1(self, mock_record_time_of_operation): + def test_perform_testing_single_level_dir(self, mock_record_time_of_operation): mock_record_time_of_operation.return_value = [1, 1, 1] gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( DIRECTORY_STRUCTURE1.folders, 'fake_bucket', 'fake_disk', 3, 'ls -R') @@ -234,7 +234,7 @@ def test_perform_testing_type1(self, mock_record_time_of_operation): self.assertEqual(gcs_bucket_results, {}) @patch('listing_benchmark._record_time_of_operation') - def test_perform_testing_type2(self, mock_record_time_of_operation): + def test_perform_testing_double_level_dir(self, mock_record_time_of_operation): mock_record_time_of_operation.return_value = [1, 1, 1] gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( DIRECTORY_STRUCTURE2.folders, 'fake_bucket', 'fake_disk', 3, 'ls -R') @@ -247,7 +247,7 @@ def test_perform_testing_type2(self, mock_record_time_of_operation): }) @patch('listing_benchmark._record_time_of_operation', return_value=[1]) - def test_perform_testing_type3(self, mock_record_time_of_operation): + def test_perform_testing_multi_level_dir(self, mock_record_time_of_operation): mock_record_time_of_operation.return_value = [1, 1] gcs_bucket_results, persistent_disk_results = listing_benchmark._perform_testing( DIRECTORY_STRUCTURE3.folders, 'fake_bucket', 'fake_disk', 2, 'ls -R') @@ -261,7 +261,7 @@ def test_perform_testing_type3(self, mock_record_time_of_operation): @patch('listing_benchmark.subprocess.call', return_value=0) @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type1(self, mock_generate_files, mock_subprocess_call): + def test_create_directory_structure_single_level_dir(self, mock_generate_files, mock_subprocess_call): exit_code = listing_benchmark._create_directory_structure( 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE1, True) self.assertEqual(exit_code, 0) @@ -274,7 +274,7 @@ def test_create_directory_structure_type1(self, mock_generate_files, mock_subpro @patch('listing_benchmark.subprocess.call', return_value=0) @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type2(self, mock_generate_files, mock_subprocess_call): + def test_create_directory_structure_double_level_dir(self, mock_generate_files, mock_subprocess_call): exit_code = listing_benchmark._create_directory_structure( 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE2, True) self.assertEqual(exit_code, 0) @@ -296,7 +296,7 @@ def test_create_directory_structure_type2(self, mock_generate_files, mock_subpro @patch('listing_benchmark.subprocess.call', return_value=0) @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=0) - def test_create_directory_structure_type3(self, mock_generate_files, mock_subprocess_call): + def test_create_directory_structure_multi_level_dir(self, mock_generate_files, mock_subprocess_call): exit_code = listing_benchmark._create_directory_structure( 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE3, True) self.assertEqual(exit_code, 0) @@ -336,7 +336,7 @@ def test_create_directory_structure_type3(self, mock_generate_files, mock_subpro @patch('listing_benchmark.subprocess.call', return_value=0) @patch('listing_benchmark.generate_files.generate_files_and_upload_to_gcs_bucket', return_value=1) - def test_create_directory_structure_error_type3(self, mock_generate_files, mock_subprocess_call): + def test_create_directory_structure_error_multi_level_dir(self, mock_generate_files, mock_subprocess_call): exit_code = listing_benchmark._create_directory_structure( 'fake_bucket_url/', 'fake_disk_url/', DIRECTORY_STRUCTURE3, True) self.assertGreater(exit_code, 0) @@ -358,13 +358,13 @@ def test_create_directory_structure_error_type3(self, mock_generate_files, mock_ ]) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type1(self, mock_list): + def test_compare_directory_structure_true_single_level_dir(self, mock_list): mock_list.side_effect = [['fake_bucket/']] result = listing_benchmark._compare_directory_structure('fake_bucket/', DIRECTORY_STRUCTURE1) self.assertTrue(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type2(self, mock_list): + def test_compare_directory_structure_true_double_level_dir(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], @@ -379,7 +379,7 @@ def test_compare_directory_structure_true_type2(self, mock_list): self.assertTrue(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_type2(self, mock_list): + def test_compare_directory_structure_false_file_double_level_dir_test1(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], @@ -394,7 +394,7 @@ def test_compare_directory_structure_false_file_type2(self, mock_list): self.assertFalse(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_folder_type2(self, mock_list): + def test_compare_directory_structure_false_folder_double_level_dir(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/file', 'fake_bucket/2KB_3files_0subdir/', 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], @@ -409,7 +409,7 @@ def test_compare_directory_structure_false_folder_type2(self, mock_list): self.assertFalse(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_type2(self, mock_list): + def test_compare_directory_structure_false_file_double_level_dir_test2(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/2KB_3files_0subdir/', 'fake_bucket/1KB_2files_0subdir/', 'fake_bucket/1KB_0files_0subdir/'], @@ -424,7 +424,7 @@ def test_compare_directory_structure_false_file_type2(self, mock_list): self.assertFalse(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_true_type3(self, mock_list): + def test_compare_directory_structure_true_multi_level_dir(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/1KB_4files_3subdir/', 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], @@ -452,7 +452,7 @@ def test_compare_directory_structure_true_type3(self, mock_list): self.assertTrue(result) @patch('listing_benchmark._list_directory') - def test_compare_directory_structure_false_file_folder_type3(self, mock_list): + def test_compare_directory_structure_false_file_folder_multi_level_dir(self, mock_list): mock_list.side_effect = [ ['fake_bucket/', 'fake_bucket/file1', 'fake_bucket/1KB_4files_3subdir/', 'fake_bucket/2KB_3files_1subdir/', 'fake_bucket/1KB_1files_0subdir/'], From f964e6008991295fa61df4ee083f52e473a4c324 Mon Sep 17 00:00:00 2001 From: Pranjal Date: Wed, 3 Aug 2022 09:04:26 +0000 Subject: [PATCH 7/7] rounding off numbers to 3 places. --- .../scripts/ls_metrics/listing_benchmark.py | 18 +++---- .../ls_metrics/listing_benchmark_test.py | 50 +++++++++---------- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark.py b/perfmetrics/scripts/ls_metrics/listing_benchmark.py index aa75708f71..f579b013a8 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark.py @@ -81,18 +81,18 @@ def _parse_results(folders, results_list, message, num_samples) -> dict: # Sorting based on time. results_list[testing_folder.name] = sorted(results_list[testing_folder.name]) - metrics[testing_folder.name]['Mean'] = stat.mean(results_list[testing_folder.name]) - metrics[testing_folder.name]['Median'] = stat.median(results_list[testing_folder.name]) - metrics[testing_folder.name]['Standard Dev'] = stat.stdev(results_list[testing_folder.name]) + metrics[testing_folder.name]['Mean'] = round(stat.mean(results_list[testing_folder.name]), 3) + metrics[testing_folder.name]['Median'] = round(stat.median(results_list[testing_folder.name]), 3) + metrics[testing_folder.name]['Standard Dev'] = round(stat.stdev(results_list[testing_folder.name]), 3) metrics[testing_folder.name]['Quantiles'] = dict() for percentile in range(0, 100, 20): - metrics[testing_folder.name]['Quantiles']['{} %ile'.format(percentile)] = np.percentile(results_list[testing_folder.name], percentile) - metrics[testing_folder.name]['Quantiles']['90 %ile'] = np.percentile(results_list[testing_folder.name], 90) - metrics[testing_folder.name]['Quantiles']['95 %ile'] = np.percentile(results_list[testing_folder.name], 95) - metrics[testing_folder.name]['Quantiles']['98 %ile'] = np.percentile(results_list[testing_folder.name], 98) - metrics[testing_folder.name]['Quantiles']['99 %ile'] = np.percentile(results_list[testing_folder.name], 99) - metrics[testing_folder.name]['Quantiles']['100 %ile'] = np.percentile(results_list[testing_folder.name], 100) + metrics[testing_folder.name]['Quantiles']['{} %ile'.format(percentile)] = round(np.percentile(results_list[testing_folder.name], percentile), 3) + metrics[testing_folder.name]['Quantiles']['90 %ile'] = round(np.percentile(results_list[testing_folder.name], 90), 3) + metrics[testing_folder.name]['Quantiles']['95 %ile'] = round(np.percentile(results_list[testing_folder.name], 95), 3) + metrics[testing_folder.name]['Quantiles']['98 %ile'] = round(np.percentile(results_list[testing_folder.name], 98), 3) + metrics[testing_folder.name]['Quantiles']['99 %ile'] = round(np.percentile(results_list[testing_folder.name], 99), 3) + metrics[testing_folder.name]['Quantiles']['100 %ile'] = round(np.percentile(results_list[testing_folder.name], 100), 3) print(metrics) return metrics diff --git a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py index a205ae9520..7a94ff7717 100644 --- a/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py +++ b/perfmetrics/scripts/ls_metrics/listing_benchmark_test.py @@ -147,20 +147,20 @@ def test_parse_results_double_level_dir(self): { 'Test Desc.': 'fake_test', 'Number of samples': 5, - 'Mean': 0.517818, + 'Mean': 0.518, 'Median': 0.222, - 'Standard Dev': 0.5559497869592182, + 'Standard Dev': 0.556, 'Quantiles': { - '0 %ile': 0.01709, - '20 %ile': 0.100218, - '40 %ile': 0.1816, - '60 %ile': 0.5311999999999999, - '80 %ile': 1.0428, - '90 %ile': 1.1384, - '95 %ile': 1.1862, - '98 %ile': 1.21488, - '99 %ile': 1.22444, + '0 %ile': 0.017, + '20 %ile': 0.1, + '40 %ile': 0.182, + '60 %ile': 0.531, + '80 %ile': 1.043, + '90 %ile': 1.138, + '95 %ile': 1.186, + '98 %ile': 1.215, + '99 %ile': 1.224, '100 %ile': 1.234 } }, @@ -170,18 +170,18 @@ def test_parse_results_double_level_dir(self): 'Number of samples': 5, 'Mean': 19.965, 'Median': 1.95, - 'Standard Dev': 39.504362202166995, + 'Standard Dev': 39.504, 'Quantiles': { '0 %ile': 0.001, - '20 %ile': 0.2674, - '40 %ile': 1.3036, - '60 %ile': 4.005999999999999, - '80 %ile': 23.762000000000015, - '90 %ile': 57.10600000000001, - '95 %ile': 73.77799999999999, - '98 %ile': 83.7812, - '99 %ile': 87.1156, + '20 %ile': 0.267, + '40 %ile': 1.304, + '60 %ile': 4.006, + '80 %ile': 23.762, + '90 %ile': 57.106, + '95 %ile': 73.778, + '98 %ile': 83.781, + '99 %ile': 87.116, '100 %ile': 90.45 } }, @@ -191,18 +191,18 @@ def test_parse_results_double_level_dir(self): 'Number of samples': 5, 'Mean': 37, 'Median': 21, - 'Standard Dev': 39.62953444086872, + 'Standard Dev': 39.63, 'Quantiles': { '0 %ile': 6.0, '20 %ile': 6.8, - '40 %ile': 15.400000000000002, + '40 %ile': 15.4, '60 %ile': 33.0, - '80 %ile': 60.80000000000001, + '80 %ile': 60.8, '90 %ile': 80.4, - '95 %ile': 90.19999999999999, + '95 %ile': 90.2, '98 %ile': 96.08, - '99 %ile': 98.03999999999999, + '99 %ile': 98.04, '100 %ile': 100.0 } }