Merge lp:~pwlars/lava-test/hwsw into lp:lava-test/0.0

[Paul Larson]

A few minor cleanups to make fields more compliant with what the dashboard will expect, and add the hardware/software profile to the data that is generated when the test is executed.

[James Westby (james-w)]

Looks good.

Thanks,

James

review: Approve

=== modified file 'abrek/swprofile.py'
--- abrek/swprofile.py	2010-08-04 17:29:48 +0000
+++ abrek/swprofile.py	2010-08-10 17:31:01 +0000
@@ -19,8 +19,7 @@
             packages.append(pkg)
     return packages
 
-def get_sw_context(test_id, time_check=False, apt_cache=None,
-                  lsb_information=None):
+def get_sw_context(apt_cache=None, lsb_information=None):
     """ Return dict used for storing sw_context information
 
     test_id - Unique identifier for this test
@@ -32,8 +31,6 @@
     sw_context = {}
     sw_context['sw_image'] = get_sw_image(lsb_information)
     sw_context['packages'] = get_packages(apt_cache)
-    sw_context['time_check_performed'] = time_check
-    sw_context['test_id'] = test_id
     return sw_context
 
 def get_sw_image(lsb_information=None):

=== modified file 'abrek/test_definitions/stream.py'
--- abrek/test_definitions/stream.py	2010-07-26 14:20:59 +0000
+++ abrek/test_definitions/stream.py	2010-08-10 17:31:01 +0000
@@ -4,11 +4,11 @@
 MD5="b6cd43b848e0d8b0824703369392f3c5"
 INSTALLSTEPS = ['cc stream.c -O2 -fopenmp -o stream']
 RUNSTEPS = ['./stream']
-PATTERN = "^(?P<testid>\w+):\W+(?P<result>\d+\.\d+)"
+PATTERN = "^(?P<test_case_id>\w+):\W+(?P<measurement>\d+\.\d+)"
 
 streaminst = abrek.testdef.AbrekTestInstaller(INSTALLSTEPS, url=URL, md5=MD5)
 streamrun = abrek.testdef.AbrekTestRunner(RUNSTEPS)
 streamparser = abrek.testdef.AbrekTestParser(PATTERN,
-                             appendall={'units':'MB/s'})
+               appendall={'units':'MB/s', 'result':'pass'})
 testobj = abrek.testdef.AbrekTest(testname="stream", installer=streaminst,
                                   runner=streamrun, parser=streamparser)

=== modified file 'abrek/testdef.py'
--- abrek/testdef.py	2010-07-26 14:20:59 +0000
+++ abrek/testdef.py	2010-08-10 17:31:01 +0000
@@ -7,9 +7,12 @@
 import time
 from commands import getstatusoutput
 from datetime import datetime
+from uuid import uuid1
 
 from abrek.config import get_config
 from abrek.utils import geturl, write_file
+from abrek import hwprofile
+from abrek import swprofile
 
 class AbrekTest(object):
     """Base class for defining tests.
@@ -72,12 +75,18 @@
             shutil.rmtree(path)
 
     def _savetestdata(self):
+        TIMEFORMAT = '%Y-%m-%dT%H:%M:%SZ'
         testdata = {}
         filename = os.path.join(self.resultsdir, 'testdata.json')
-        testdata['testname'] = self.testname
-        testdata['version'] = self.version
-        testdata['starttime'] = time.mktime(self.runner.starttime.timetuple())
-        testdata['endtime'] = time.mktime(self.runner.endtime.timetuple())
+        testdata['test_id'] = self.testname
+        testdata['analyzer_assigned_uuid'] = str(uuid1())
+        testdata['time_check_performed'] = False
+        testdata['analyzer_assigned_date'] = datetime.strftime(
+                                             self.runner.starttime,TIMEFORMAT)
+        hw = hwprofile.get_hw_context()
+        testdata['hw_context'] = hw
+        sw = swprofile.get_sw_context()
+        testdata['sw_context'] = sw
         write_file(json.dumps(testdata), filename)
 
     def run(self):
@@ -199,27 +208,27 @@
             "test01:  PASS", then you could use a pattern like this:
             "^(?P<testid>\w+):\W+(?P<result>\w+)"
             This would result in identifying "test01" as testid and "PASS"
-            as result.  Once parse() has been called, self.results.testlist[]
+            as result.  Once parse() has been called, self.results.test_results[]
             contains a list of dicts of all the key,value pairs found for
             each test result
     fixupdict - dict of strings to convert test results to standard strings
         For example: if you want to standardize on having pass/fail results
             in lower case, but your test outputs them in upper case, you could
             use a fixupdict of something like: {'PASS':'pass','FAIL':'fail'}
-    appendall - Append a dict to the testlist entry for each result.
+    appendall - Append a dict to the test_results entry for each result.
         For example: if you would like to add units="MB/s" to each result:
             appendall={'units':'MB/s'}
     """
     def __init__(self, pattern=None, fixupdict=None, appendall={}):
         self.pattern = pattern
         self.fixupdict = fixupdict
-        self.results = {'testlist':[]}
+        self.results = {'test_results':[]}
         self.appendall = appendall
 
     def _find_testid(self, id):
-        for x in self.results['testlist']:
+        for x in self.results['test_results']:
             if x['testid'] == id:
-                return self.results['testlist'].index(x)
+                return self.results['test_results'].index(x)
 
     def parse(self):
         """Parse test output to gather results
@@ -235,27 +244,27 @@
             for line in fd.readlines():
                 match = pat.search(line)
                 if match:
-                    self.results['testlist'].append(match.groupdict())
+                    self.results['test_results'].append(match.groupdict())
         if self.fixupdict:
             self.fixresults(self.fixupdict)
         if self.appendall:
             self.appendtoall(self.appendall)
 
     def append(self, testid, entry):
-        """Appends a dict to the testlist entry for a specified testid
+        """Appends a dict to the test_results entry for a specified testid
 
         This lets you add a dict to the entry for a specific testid
         entry should be a dict, updates it in place
         """
         index = self._find_testid(testid)
-        self.results['testlist'][index].update(entry)
+        self.results['test_results'][index].update(entry)
 
     def appendtoall(self, entry):
-        """Append entry to each item in the testlist.
+        """Append entry to each item in the test_results.
 
-        entry - dict of key,value pairs to add to each item in the testlist
+        entry - dict of key,value pairs to add to each item in the test_results
         """
-        for t in self.results['testlist']:
+        for t in self.results['test_results']:
             t.update(entry)
 
     def fixresults(self, fixupdict):
@@ -266,7 +275,7 @@
             {"TPASS":"pass", "TFAIL":"fail"}
         This is really only used for qualitative tests
         """
-        for t in self.results['testlist']:
+        for t in self.results['test_results']:
             if t.has_key("result"):
                 t['result'] = fixupdict[t['result']]
 

=== modified file 'tests/test_abrektestparser.py'
--- tests/test_abrektestparser.py	2010-07-22 14:49:49 +0000
+++ tests/test_abrektestparser.py	2010-08-10 17:31:01 +0000
@@ -28,8 +28,8 @@
         self.writeoutputlog("test001: pass")
         parser = self.makeparser(pattern)
         parser.parse()
-        self.assertTrue(parser.results["testlist"][0]["testid"] == "test001" and
-                        parser.results["testlist"][0]["result"] == "pass")
+        self.assertTrue(parser.results["test_results"][0]["testid"] == "test001" and
+                        parser.results["test_results"][0]["result"] == "pass")
 
     def test_fixupdict(self):
         pattern = "^(?P<testid>\w+):\W+(?P<result>\w+)"
@@ -37,7 +37,7 @@
         self.writeoutputlog("test001: pass")
         parser = self.makeparser(pattern, fixupdict=fixup)
         parser.parse()
-        self.assertEquals("PASS", parser.results["testlist"][0]["result"])
+        self.assertEquals("PASS", parser.results["test_results"][0]["result"])
 
     def test_appendall(self):
         pattern = "^(?P<testid>\w+):\W+(?P<result>\w+)"
@@ -45,5 +45,5 @@
         self.writeoutputlog("test001: pass")
         parser = self.makeparser(pattern, appendall=append)
         parser.parse()
-        self.assertEqual("foo/s", parser.results["testlist"][0]["units"])
+        self.assertEqual("foo/s", parser.results["test_results"][0]["units"])
 

=== modified file 'tests/test_swprofile.py'
--- tests/test_swprofile.py	2010-08-04 17:29:48 +0000
+++ tests/test_swprofile.py	2010-08-10 17:31:01 +0000
@@ -26,12 +26,12 @@
         self.testpackage = Package('testpkg', '7.77')
         self.cache = AptCache([self.testpackage])
 
-    def make_profile(self, test_id='unit', cache=None, info=None):
+    def make_profile(self, cache=None, info=None):
         if cache == None:
             cache = self.cache
         if info == None:
             info = self.lsb_information
-        return abrek.swprofile.get_sw_context(test_id, apt_cache=cache,
+        return abrek.swprofile.get_sw_context(apt_cache=cache,
                 lsb_information=info)
 
     def test_pkg_name(self):