Merge lp:~liuyq0307/lava-android-test/customize-attachments into lp:lava-android-test

[Yongqin Liu]

Add support to adding customized attachment to the bundle.
Like the result.zip of cts test

have tested it locally.

[Senthil Kumaran S (stylesen)]

Looks good +1 to merge.

review: Approve

=== modified file 'lava_android_test/commands.py'
--- lava_android_test/commands.py	2013-04-11 20:22:18 +0000
+++ lava_android_test/commands.py	2013-05-18 08:57:37 +0000
@@ -816,22 +816,17 @@
         stderr_text = ''
     bundle['test_runs'][0]["test_results"] = test_tmp.parser.results[
                                                         "test_results"]
-    bundle['test_runs'][0]["attachments"] = [
-        {
-            "pathname": test_tmp.org_ouput_file,
-            "mime_type": "text/plain",
-            "content":  base64.standard_b64encode(stdout_text)
-        },
-        {
-            "pathname": 'stderr.log',
-            "mime_type": "text/plain",
-            "content":  base64.standard_b64encode(stderr_text)
-        }
-    ]
-
-    _gather_screencaps(resultdir, adb, bundle, config)
-    _gather_tombstones(adb, bundle, config)
-
+
+    ## following part is used for generating the attachment for normal test
+    attachment_bundles = []
+    for attachment in test_tmp.attachments:
+        data_bundle = attachment.generate_bundle(adb=adb, resultsdir=resultdir)
+        if data_bundle:
+            attachment_bundles.append(data_bundle)
+
+    bundle['test_runs'][0]["attachments"] = attachment_bundles
+
+    ##following used for the attachment for monkeyrunner test
     for attach in attachments:
         if os.path.exists(attach):
             with open(attach, 'rb') as stream:
@@ -843,52 +838,6 @@
                             "content": base64.standard_b64encode(data)})
     return bundle
 
-def _gather_screencaps(resultdir, adb, bundle, config):
-    """
-    Extension of the generate bundle function.
-    Grabs the screencaps and appends them to the bundle.
-     """
-    screencap_path = os.path.join(resultdir, 'screencap.png')
-    if adb.exists(screencap_path):
-        tmp_path = os.path.join(config.tempdir_host, 'screencap.png')
-        adb.pull(screencap_path, tmp_path)
-        with open(tmp_path, 'rb') as stream:
-            data = stream.read()
-        if data:
-            bundle['test_runs'][0]["attachments"].append({
-            "pathname": 'screencap.png',
-            "mime_type": 'image/png',
-            "content": base64.standard_b64encode(data)})
-        os.unlink(tmp_path)
-
-
-def _gather_tombstones(adb , bundle, config):
-    """
-    Extension of the generate bundle function.
-    Grabs the tombstones and appends them to the bundle.
-    """
-    tombstone_path = '/data/tombstones'
-    tombstone_zip =  os.path.join(config.tempdir_host,'tombstones.zip')
-    if adb.exists(tombstone_path):
-        tmp_path = os.path.join(config.tempdir_host, 'tombstones')
-        adb.pull(tombstone_path, tmp_path)
-        adb.shell("rm -R " + tombstone_path)
-        zipf = zipfile.ZipFile(tombstone_zip, mode='w')
-        for rootdir, dirs, files in os.walk(tmp_path):
-            for f in files:
-                zipf.write(os.path.join(rootdir, f), arcname=f)
-        zipf.close()
-
-        with open(tombstone_zip, 'rb') as stream:
-            data = stream.read()
-        if data:
-            bundle['test_runs'][0]["attachments"].append({
-            "pathname": 'tombstones.zip',
-            "mime_type": 'application/zip',
-            "content": base64.standard_b64encode(data)})
-        os.unlink(tombstone_zip)
-
-
 class show(AndroidResultCommand):
     """
     Display the output from a previous test that run on the specified device


=== modified file 'lava_android_test/test_definitions/cts.py'
--- lava_android_test/test_definitions/cts.py	2013-03-20 08:20:57 +0000
+++ lava_android_test/test_definitions/cts.py	2013-05-18 08:57:37 +0000
@@ -45,7 +45,13 @@
            "\s+(?P<result>\S+)\s*$")
 parser = lava_android_test.testdef.AndroidTestParser(pattern=pattern,
                             fixupdict={'PASS': 'pass', 'FAIL': 'fail'})
+
+attachments = [lava_android_test.testdef.Attachment(
+                            pathname="/data/local/tmp/cts-results.zip",
+                            mime_type="application/zip")
+                ]
 testobj = lava_android_test.testdef.AndroidTest(testname=test_name,
                                                 installer=inst,
                                                 runner=run,
-                                                parser=parser)
+                                                parser=parser,
+                                                attachments=attachments)

=== modified file 'lava_android_test/test_definitions/cts/cts_wrapper.py'
--- lava_android_test/test_definitions/cts/cts_wrapper.py	2013-05-06 08:26:27 +0000
+++ lava_android_test/test_definitions/cts/cts_wrapper.py	2013-05-18 08:57:37 +0000
@@ -27,6 +27,7 @@
 import xml.dom.minidom
 from lava_android_test.adb import ADB
 from lava_android_test.utils import stop_at_pattern
+from lava_android_test.utils import find_files
 
 adb = ADB(sys.argv[1])
 curdir = os.path.realpath(os.path.dirname(__file__))
@@ -53,6 +54,10 @@
     finally:
         proc_cts.sendcontrol('C')
         proc_cts.sendline('')
+        target_dir = os.path.join(os.getcwd(),
+                                  './android-cts/repository/results/')
+        for zip_f in find_files(target_dir, '.zip'):
+            adb.push(zip_f, '/data/local/tmp/cts-results.zip')
 
     return result
 
@@ -247,7 +252,7 @@
 
     package_name = None
     plan_name = 'CTS'
-    class_name= None
+    class_name = None
     method_name = None
     timeout = 36000
     #--cts_pkg cts_package_file --package package_name --timeout 36000

=== modified file 'lava_android_test/testdef.py'
--- lava_android_test/testdef.py	2013-04-08 06:35:17 +0000
+++ lava_android_test/testdef.py	2013-05-18 08:57:37 +0000
@@ -17,13 +17,17 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import base64
 import hashlib
+import logging
 import os
 import re
 import string
 import time
 import tempfile
 import decimal
+import zipfile
+
 from datetime import datetime
 from uuid import uuid4
 
@@ -35,6 +39,57 @@
 from linaro_dashboard_bundle.io import DocumentIO
 
 
+class Attachment(object):
+
+    def __init__(self, pathname=None, mime_type=None):
+        self.pathname = pathname
+        self.mime_type = mime_type
+
+    def copy_to_result_dir(self, adb=None, resultsdir=None):
+        """
+        Copy the file specified by the pathname to result
+        directory of this time test, beacuse some test will
+        generate the result to the same path file.
+        And Please Note that pathname must be the absolute
+        path in the device.
+        """
+        if (not self.pathname) or (not self.pathname.startswith('/')):
+            return
+        if not resultsdir:
+            return
+        if not adb:
+            adb = ADB()
+        if not adb.exists(resultsdir):
+            adb.makedirs(resultsdir)
+        ret_code = adb.copy(self.pathname, os.path.join(resultsdir,
+                                     os.path.basename(self.pathname)))
+        if ret_code != 0:
+            raise RuntimeError(
+                    "Failed to copy file '%s' to '%s' on device(%s)" %
+                        (self.pathname, resultsdir, adb.get_serial()))
+
+    def generate_bundle(self, adb=None, resultsdir=None):
+        data_bundle = {}
+        if not self.pathname:
+            return data_bundle
+        if not adb:
+            adb = ADB()
+        config = get_config()
+        basename = os.path.basename(self.pathname)
+        android_path = os.path.join(resultsdir, basename)
+        if adb.exists(android_path):
+            tmp_path = os.path.join(config.tempdir_host, basename)
+            adb.pull(android_path, tmp_path)
+            with open(tmp_path, 'rb') as stream:
+                data = stream.read()
+            if data:
+                data_bundle = {"pathname": basename,
+                               "mime_type": self.mime_type,
+                               "content": base64.standard_b64encode(data)}
+            os.unlink(tmp_path)
+        return data_bundle
+
+
 class AndroidTest(ITest):
     """Base class for defining tests.
 
@@ -49,6 +104,12 @@
     parser - AbrekParser instance to use
     """
     adb = ADB()
+    default_attachments = [
+        Attachment(pathname="stderr.log", mime_type="text/plain"),
+        Attachment(pathname="stdout.log", mime_type="text/plain"),
+        Attachment(pathname="screencap.png", mime_type="image/png"),
+        Attachment(pathname="tombstones.zip", mime_type="application/zip")
+        ]
 
     def setadb(self, adb=None):
         self.adb = adb
@@ -58,7 +119,8 @@
 
     def __init__(self, testname, version="", installer=None, runner=None,
                  parser=None, default_options=None,
-                 org_ouput_file='stdout.log'):
+                 org_ouput_file='stdout.log',
+                 attachments=[]):
         self.testname = testname
         self.version = version
         self.installer = installer
@@ -67,6 +129,13 @@
         self.default_options = default_options
         self.org_ouput_file = org_ouput_file
         self.origdir = os.path.abspath(os.curdir)
+        self.attachments = self.default_attachments
+        if self.org_ouput_file and (self.org_ouput_file != "stdout.log"):
+            self.attachments.append(
+                Attachment(pathname=self.org_ouput_file,
+                           mime_type="text/plain"))
+        if attachments:
+            self.attachments.extend(attachments)
 
     def set_runner(self, runner=None):
         self.runner = runner
@@ -153,7 +222,7 @@
             ]
         }
         if run_options:
-             bundle['test_runs'][0]['attributes']['run_options'] = run_options
+            bundle['test_runs'][0]['attributes']['run_options'] = run_options
         self._add_install_options(bundle, config)
         filename_host = os.path.join(config.tempdir_host, 'testdata.json')
         write_file(DocumentIO.dumps(bundle), filename_host)
@@ -177,7 +246,8 @@
         self.resultsdir = os.path.join(config.resultsdir_android, resultname)
         self.adb.makedirs(self.resultsdir)
         self.runner.run(self.resultsdir, run_options=run_options)
-        self._copyorgoutputfile(self.resultsdir)
+        self._gather_tombstones(self.resultsdir)
+        self._copyattachments(self.resultsdir)
         self._screencap(self.resultsdir)
         self._savetestdata(str(uuid4()), run_options=run_options)
         result_id = os.path.basename(self.resultsdir)
@@ -190,17 +260,30 @@
         self.adb.shell('%s %s' % (target_path, os.path.join(resultsdir,
                                                         'screencap.png')))
 
-    def _copyorgoutputfile(self, resultsdir):
-        if self.org_ouput_file == 'stdout.log':
-            return
-        if not self.adb.exists(resultsdir):
-            self.adb.makedirs(resultsdir)
-        ret_code = self.adb.copy(self.org_ouput_file, os.path.join(resultsdir,
-                                     os.path.basename(self.org_ouput_file)))
-        if ret_code != 0:
-            raise RuntimeError(
-                    "Failed to copy file '%s' to '%s' for test(%s)" %
-                        (self.org_ouput_file, resultsdir, self.testname))
+    def _gather_tombstones(self, resultsdir):
+        """
+        Extension of the generate bundle function.
+        Grabs the tombstones and appends them to the bundle.
+        """
+        config = get_config()
+        tombstone_path = '/data/tombstones'
+        tombstone_zip = os.path.join(config.tempdir_host, 'tombstones.zip')
+        if self.adb.exists(tombstone_path):
+            tmp_path = os.path.join(config.tempdir_host, 'tombstones')
+            self.adb.pull(tombstone_path, tmp_path)
+            self.adb.shell("rm -R " + tombstone_path)
+            zipf = zipfile.ZipFile(tombstone_zip, mode='w')
+            for rootdir, dirs, files in os.walk(tmp_path):
+                for f in files:
+                    zipf.write(os.path.join(rootdir, f), arcname=f)
+            zipf.close()
+            self.adb.push(tombstone_zip, os.path.join(resultsdir,
+                                                      'tombstones.zip'))
+            os.unlink(tombstone_zip)
+
+    def _copyattachments(self, resultsdir):
+        for attachment in self.attachments:
+            attachment.copy_to_result_dir(adb=self.adb, resultsdir=resultsdir)
 
     def parse(self, resultname):
         if not self.parser:
@@ -607,6 +690,7 @@
         self.fixmeasurements()
         self.fixids()
 
+
 class AndroidSimpleTestParser(AndroidTestParser):
 
     def real_parse(self, result_filename='stdout.log',