Merge lp:~canonical-platform-qa/ubuntu-test-cases/memevent-nfss-data-file into lp:~canonical-platform-qa/ubuntu-test-cases/memevent

[Christopher Lee]

Update the nfss upload script to generate single json files (per test) that can be uploaded to the nfss backend via the infrastructure supplied mechanisms.

Update the nfss upload script to generate single json files (per test) that can be uploaded to the nfss backend via the infrastructure supplied mechanisms.

=== added directory 'tests/memevent/support_scripts'
=== added file 'tests/memevent/support_scripts/__init__.py'
=== renamed file 'tests/memevent/nfss_upload_results.py' => 'tests/memevent/support_scripts/generate_nfss_result_file.py'
--- tests/memevent/nfss_upload_results.py	2014-10-22 21:39:57 +0000
+++ tests/memevent/support_scripts/generate_nfss_result_file.py	2014-11-06 00:30:46 +0000
@@ -1,10 +1,14 @@
 #!/usr/bin/python3
 
-"""This script takes memevent-test result json files and uploads the
-interesting data contained within to a nfss backend.
-
-It will process any memory result files found in 'source_file_path matching the
-naming scheme: "memory_usage_*.json"
+"""This script takes memevent-test result json files and generates a single
+containing json file for each test.
+
+These files can then be uploaded to the nfss backend.
+
+The script takes two arguments <source file path> and <destination path>
+It will process any memory result files found in <source file_path> matching
+the naming scheme: "memory_usage_*.json" and write the amalgamated results file
+into <destination path>
 
 """
 
@@ -18,10 +22,6 @@
 from collections import defaultdict
 from glob import glob
 
-source_file_path = ""
-upload_script = ""
-nfss_config = ""
-
 
 def _get_run_details(app_name):
     return dict(
@@ -52,50 +52,19 @@
         return "Unknown"
 
 
-def upload_json_details(run_details, app_details):
-    app_run_details = run_details.copy()
-    app_run_details["events"] = app_details
-
-    _upload_data(run_details['application_name'], app_run_details)
-
-
-def _upload_data(test_name, run_json):
-    try:
-        run_json_string = json.dumps(run_json)
-    except ValueError as e:
-        print("Error: Data does not appear to be valid json: %s" % e)
-        sys.exit(3)
-
-    print("Uploading data for :memevent:-", test_name)
-    global upload_script
-    global nfss_config
-    try:
-        upload_process = subprocess.Popen(
-            [upload_script, nfss_config, 'memevent', test_name],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        stdout, stderr = upload_process.communicate(
-            input=run_json_string.encode()
-        )
-        print("stdout: {}\n\nstderr: {}".format(stdout, stderr))
-    except Exception as e:
-        print("Something went terribly wrong: ", e)
-    if upload_process.returncode != 0:
-        raise subprocess.CalledProcessError('Failed to upload to nfss')
-
-
 def _get_files_app_name_and_test(filename):
     """return tuple containing (appname, testname)."""
     app_name_search = re.search(
         'memory_usage_([a-zA-Z-]*).(.*)\.json',
         filename
     )
+    if "" in app_name_search.groups():
+        raise ValueError("Cannot find app and/or test name: %s" % filename)
     return (app_name_search.group(1), app_name_search.group(2))
 
 
 def get_application_readings(json_data):
+    """Returns a list of result event data."""
     app_results = []
     pids = json_data["pids"]
     for reading in json_data["readings"]:
@@ -115,6 +84,8 @@
 
 
 def get_application_results(json_filepath):
+    """Load a json file into memory, return the a list of event readings from
+    it."""
     with open(json_filepath, "r") as f:
         json_data = json.load(f)
     return get_application_readings(json_data)
@@ -122,63 +93,96 @@
 
 def get_application_details(application_files):
     """For every file this application has grab out the details and return a
-    list dictionaries containing reading details.
+    list of dictionaries containing reading details.
+
+    Given a list of json files for an application extract its results and
+    return a list of results for this application.
 
     """
     app_result = []
     for json_file in application_files:
-        app_result.extend(get_application_results(json_file))
+        json_results = get_application_results(json_file)
+        app_result.extend(json_results)
     return app_result
 
 
-def map_files_to_applications():
-    """For any memory result files that exist, return a dictionary whos keys
-    are the applications name mapped to the file.
+def map_files_to_applications(test_file_paths_list):
+    """For any memory result files that exist at **source_file_path**, return a
+    dictionary whos keys are the applications name and the values the file path
+    for that apps results.
 
     We can then produce a single json result for each application regardless of
     there being many tests / results for it.
 
     """
-
-    global source_file_path
-    json_results_filename_pattern = os.path.join(
-        source_file_path,
-        "memory_usage_*.json"
-    )
     file_map = defaultdict(list)
-    for json_result_file in glob(json_results_filename_pattern):
+    for json_result_file in test_file_paths_list:
         app_name, test_name = _get_files_app_name_and_test(json_result_file)
         file_map[app_name].append(json_result_file)
     return file_map
 
 
-def usage():
-    print("{} <source file path> <nfss upload script> <nfss config file>"
-          .format(sys.argv[0]))
-
-
-def main():
-    if len(sys.argv) != 4:
-        usage()
-        exit(1)
-
-    global source_file_path
-    source_file_path = sys.argv[1]
-
-    global upload_script
-    upload_script = sys.argv[2]
-
-    global nfss_config
-    nfss_config = sys.argv[3]
-
+def get_all_applications_details(test_result_files):
+    """Create a map of [application name] = [list of result event data]."""
     app_details = dict()
-    file_map = map_files_to_applications()
+    file_map = map_files_to_applications(test_result_files)
     for app_name in file_map.keys():
         app_details[app_name] = get_application_details(file_map[app_name])
 
-    for app_name in app_details.keys():
+    return app_details
+
+
+def get_test_result_files(source_file_path):
+    json_results_filename_pattern = os.path.join(
+            source_file_path,
+            "memory_usage_*.json"
+        )
+    return glob(json_results_filename_pattern)
+
+
+def usage(extra_msg=None):
+    print("{} <source file path> <destination file>".format(sys.argv[0]))
+    if extra_msg:
+        print(extra_msg)
+
+
+def raise_on_invalid_args(argv):
+    if len(argv) != 3:
+        raise RuntimeError("Not enough arguments")
+
+
+def parse_args(argv):
+    try:
+        source_file_path = argv[1]
+        destination_file = argv[2]
+        return (source_file_path, destination_file)
+    except IndexError:
+        raise RuntimeError("Need both source path and destination file.")
+
+
+def main():
+    try:
+        raise_on_invalid_args(sys.argv)
+        source_file_path, destination_file = parse_args(sys.argv)
+    except RuntimeError as e:
+        usage(e)
+        exit(1)
+
+    test_result_files = get_test_result_files(source_file_path)
+    all_app_details = get_all_applications_details(test_result_files)
+
+    # all_app_details is a map of ['appname'] => [list|event data]
+    for app_name in all_app_details.keys():
         run_details = _get_run_details(app_name)
-        upload_json_details(run_details, app_details[app_name])
+        run_details["events"] = all_app_details[app_name]
+        # write to file for application.
+        file_output = os.path.join(
+            destination_file,
+            "{app_name}_results.json".format(app_name=app_name)
+        )
+        print("Writing results for %s to %s" %(app_name,  file_output))
+        with open(file_output, "w") as f:
+            json.dump(run_details, f)
 
 
 if __name__ == '__main__':

=== added directory 'tests/memevent/support_scripts/tests'
=== added file 'tests/memevent/support_scripts/tests/__init__.py'
=== added file 'tests/memevent/support_scripts/tests/test_nfss_result_generator.py'
--- tests/memevent/support_scripts/tests/test_nfss_result_generator.py	1970-01-01 00:00:00 +0000
+++ tests/memevent/support_scripts/tests/test_nfss_result_generator.py	2014-11-06 00:30:46 +0000
@@ -0,0 +1,76 @@
+from testtools import TestCase, ExpectedException
+from testtools.matchers import Equals
+
+from support_scripts import generate_nfss_result_file as gen_nfss
+
+
+class ScriptInteractionTests(TestCase):
+    """Ensure the script reacts as expected."""
+    def test_parse_args_returns_source_and_destination_files(self):
+        test_args = ["executable", "source", "destination"]
+        self.assertThat(
+            gen_nfss.parse_args(test_args),
+            Equals(("source", "destination"))
+        )
+
+    def test_raise_on_invalid_args_doesnt_raise_with_correct_args(self):
+        gen_nfss.raise_on_invalid_args(["executable", "source", "destination"])
+
+    def test_raise_on_invalid_args_raises_with_incorrect_args(self):
+        with ExpectedException(RuntimeError):
+            gen_nfss.raise_on_invalid_args([])
+
+
+class AppnameAndTestnameExtractionTest(TestCase):
+    """Tests for _get_files_app_name_and_test."""
+
+    def test_returns_appname_testname(self):
+        test_filename = "/some/path/memory_usage_AppName.TestName.json"
+        app_name, test_name = gen_nfss._get_files_app_name_and_test(
+            test_filename
+        )
+
+        self.assertThat(app_name, Equals("AppName"))
+        self.assertThat(test_name, Equals("TestName"))
+
+    def test_raises_exception_if_filename_missformated(self):
+        test_filename = "/some/path/memory_usage_AppName.json"
+        exception_msg = "Cannot find app and/or test name: %s" % test_filename
+        with ExpectedException(ValueError, exception_msg):
+            gen_nfss._get_files_app_name_and_test(test_filename)
+
+
+class ApplicationDetailsTests(TestCase):
+    def test_map_files_to_args_gets_multiple_files_for_app(self):
+        test_filenames = [
+            "memory_usage_AppName.Test1.json",
+            "memory_usage_AppName.Test2.json",
+        ]
+        file_map = gen_nfss.map_files_to_applications(test_filenames)
+
+        self.assertDictEqual(file_map, dict(AppName=test_filenames))
+
+    def test_map_files_to_args_only_gets_files_for_app(self):
+        test_filenames = [
+            "memory_usage_AppName.Test1.json",
+            "memory_usage_AppName.Test2.json",
+            "memory_usage_SecondAppName.Test2.json",
+        ]
+        file_map = gen_nfss.map_files_to_applications(test_filenames)
+
+        self.assertListEqual(
+            file_map['AppName'],
+            [
+                "memory_usage_AppName.Test1.json",
+                "memory_usage_AppName.Test2.json"
+            ]
+        )
+
+    # get_application_details
+
+    # get_application_results
+    # Loads file and reads in json data
+
+    # get_application_readings
+    # Reads given json data and produces a list of results for the application
+    # Needs example data.