Merge lp:~liuyq0307/lava-android-test/command-file into lp:lava-android-test

[Yongqin Liu]

1. Add support to push a specified android command file to android and run it on android.
2. Add some process for deal with the test result
3. Modify to use add_mutually_exclusive_group according review comment
4. Change result patterns to Parser member, so that we can change them out of the class

[Zygmunt Krynicki (zyga)]

32 + if self.args.android_command and self.args.command_file:
33 + raise LavaCommandError("Please specified one option of -c and -f")
34 + if not self.args.android_command and not self.args.command_file:
35 + raise LavaCommandError("Please specified one option of -c and -f")

You should use mutex group instead:

group = parser.add_mutually_exclusive_group()
group.add_argument('-f', ...)
group.add_argument('-c', ...)

Then argparse will this check for you.

53 + STEPS_HOST_PRE = ["wget %s -O %s" % (file_url, file_name)]

I'd like us to use python on the host if possible. Downloading stuff with wget eventually means we have no error handling. This can stay as-is but we should look at the problem of how we download anything throughout lava and fix it.

[Zygmunt Krynicki (zyga)]

+ if self.args.android_command and self.args.command_file:
39 + raise LavaCommandError("Please specified one option of -c and -f")
40 + if not self.args.android_command and not self.args.command_file:
41 + raise LavaCommandError("Please specified one option of -c and -f")

This won't be need if you indicate that both -c and -f are required

add_argument( ..., required=True)

Otherwise looks okay

[lp:~liuyq0307/lava-android-test/command-file]

148. By Yongqin Liu on 2012-03-18

modify to use the required option according to review comment

Unmerged revisions

=== modified file 'lava_android_test/commands.py'
--- lava_android_test/commands.py	2012-03-09 11:58:12 +0000
+++ lava_android_test/commands.py	2012-03-18 08:48:17 +0000
@@ -1,4 +1,4 @@
-# Copyright (c) 2011, 2011 Linaro
+# Copyright (c) 2011, 2012 Linaro
 #
 # Author: Linaro Validation Team <[e-mail]>
 #
@@ -18,6 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import os
 import base64
+import urlparse
 import versiontools
 
 from lava_tool.interface import Command as LAVACommand
@@ -334,10 +335,14 @@
     @classmethod
     def register_arguments(cls, parser):
         super(run_custom, cls).register_arguments(parser)
-        parser.add_argument('-c', '--android-command', action='append',
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('-c', '--android-command', action='append',
                             help=("Specified in the job file for using"
                                   " in the real test action, so that "
                                   "we can customize some test when need"))
+        group.add_argument('-f', '--command-file',
+                            help=("Specified the command file that will be "
+                                  "pushed into android and run."))
         parser.add_argument('-p', '--parse-regex',
                             help=("Specified the regular expression used"
                                   " for analyzing command output"))
@@ -351,29 +356,58 @@
                                  " to the  specified FILE."))
 
     def invoke(self):
+
+        config = get_config()
         self.adb = ADB(self.args.serial)
         test_name = 'custom'
         ADB_SHELL_STEPS = []
+        STEPS_HOST_PRE = []
+        STEPS_ADB_PRE = []
+        file_name = None
         if self.args.android_command:
             ADB_SHELL_STEPS = self.args.android_command
+            test_name_suffix = 'command=[%s]' % (','.join(ADB_SHELL_STEPS))
+        elif self.args.command_file:
+            file_url = self.args.command_file
+            urlpath = urlparse.urlsplit(file_url).path
+            file_name = os.path.basename(urlpath)
+            target_path = os.path.join(config.installdir_android,
+                                     test_name, file_name)
+            STEPS_HOST_PRE = ["wget %s -O %s" % (file_url, file_name)]
+            STEPS_ADB_PRE = ["push %s %s" % (file_name, target_path)]
+            ADB_SHELL_STEPS = ["chmod 777 %s" % target_path,
+                               target_path]
+            test_name_suffix = 'command_file=%s' % file_name
+
         PATTERN = None
         if self.args.parse_regex:
             PATTERN = self.args.parse_regex
 
         tip_msg = ''
         if self.args.serial:
-            tip_msg = "Run following custom test(s) on device(%s):\n\t\t%s" % (
-                           self.args.serial, '\n\t\t'.join(ADB_SHELL_STEPS))
+            tip_msg = ("Run following custom test(s) on device(%s):"
+                       "\n\tcommands=%s"
+                       "\n\tcommand-file=%s\n") % (
+                       self.args.serial,
+                       '\n\t\t'.join(ADB_SHELL_STEPS),
+                       file_name)
         else:
-            tip_msg = "Run following custom test(s):\n\t\t%s" % (
-                                             '\n\t\t'.join(ADB_SHELL_STEPS))
+            tip_msg = ("Run following custom test(s):"
+                       "\n\t\tcommands=%s"
+                       "\n\tcommand-file=%s\n") % (
+                       '\n\t\t'.join(ADB_SHELL_STEPS),
+                       file_name)
+
         self.say_begin(tip_msg)
 
         inst = AndroidTestInstaller()
-        run = AndroidTestRunner(adbshell_steps=ADB_SHELL_STEPS)
+
+        run = AndroidTestRunner(steps_host_pre=STEPS_HOST_PRE,
+                                steps_adb_pre=STEPS_ADB_PRE,
+                                adbshell_steps=ADB_SHELL_STEPS)
         parser = AndroidTestParser(pattern=PATTERN)
-        test = AndroidTest(testname=test_name, installer=inst,
-                                runner=run, parser=parser)
+        test = AndroidTest(testname=test_name,
+                            installer=inst, runner=run, parser=parser)
         test.parser.results = {'test_results': []}
         test.setadb(self.adb)
 
@@ -387,7 +421,8 @@
                 if not os.path.exists(output_dir):
                     os.makedirs(output_dir)
                 bundle = generate_bundle(self.args.serial,
-                                          result_id, test=test)
+                        result_id, test=test,
+                        test_id='%s(%s)' % (test_name, test_name_suffix))
                 with open(self.args.output, "wt") as stream:
                     DocumentIO.dump(stream, bundle)
 
@@ -444,14 +479,14 @@
             pass
 
 
-def generate_combined_bundle(serial=None, result_ids=None, test=None):
+def generate_combined_bundle(serial=None, result_ids=None, test=None, test_id=None):
     if result_ids is None:
         return {}
 
     bundle = None
 
     for rid in result_ids:
-        b = generate_bundle(serial, rid, test=None)
+        b = generate_bundle(serial, rid, test, test_id)
         if rid == result_ids[0]:
             bundle = b
         else:
@@ -460,7 +495,7 @@
     return bundle
 
 
-def generate_bundle(serial=None, result_id=None, test=None):
+def generate_bundle(serial=None, result_id=None, test=None, test_id=None):
     if result_id is None:
         return {}
     config = get_config()
@@ -477,19 +512,22 @@
     else:
         test_tmp = testloader(bundle['test_runs'][0]['test_id'], serial)
 
+    if test_id:
+        bundle['test_runs'][0]['test_id'] = test_id
+
     test_tmp.parse(result_id)
     stdout_text = adb.read_file(os.path.join(resultdir,
-                                  os.path.basename(test.org_ouput_file)))
+                                  os.path.basename(test_tmp.org_ouput_file)))
     if stdout_text is None:
         stdout_text = ''
     stderr_text = adb.read_file(os.path.join(resultdir, 'stderr.log'))
     if stderr_text is None:
         stderr_text = ''
-    bundle['test_runs'][0]["test_results"] = test.parser.results[
+    bundle['test_runs'][0]["test_results"] = test_tmp.parser.results[
                                                         "test_results"]
     bundle['test_runs'][0]["attachments"] = [
         {
-            "pathname": test.org_ouput_file,
+            "pathname": test_tmp.org_ouput_file,
             "mime_type": "text/plain",
             "content":  base64.standard_b64encode(stdout_text)
         },

=== modified file 'lava_android_test/testdef.py'
--- lava_android_test/testdef.py	2012-03-09 11:58:12 +0000
+++ lava_android_test/testdef.py	2012-03-18 08:48:17 +0000
@@ -20,6 +20,7 @@
 import hashlib
 import os
 import re
+import string
 import sys
 import time
 import tempfile
@@ -348,6 +349,10 @@
 
 class AndroidTestParser(object):
     adb = ADB()
+    PASS_PATS = ['PASS', 'OK', 'TRUE', 'DONE']
+    FAIL_PATS = ['FAIL', 'NG', 'FALSE']
+    SKIP_PATS = ['SKIP']
+
     """Base class for defining a test parser
 
     This class can be used as-is for simple results parsers, but will
@@ -434,8 +439,7 @@
                 if data.get('result') is None:
                     data['result'] = test_ok and 'pass' or 'fail'
                 self.results['test_results'].append(data)
-        if self.fixupdict:
-            self.fixresults(self.fixupdict)
+        self.fixresults(self.fixupdict)
         if self.appendall:
             self.appendtoall(self.appendall)
         self.fixmeasurements()
@@ -469,7 +473,29 @@
         """
         for t in self.results['test_results']:
             if "result" in t:
-                t['result'] = fixupdict[t['result']]
+                if not fixupdict:
+                    if self.is_result_match(t['result'], self.PASS_PATS):
+                        t['result'] = 'pass'
+                    elif self.is_result_match(t['result'], self.FAIL_PATS):
+                        t['result'] = 'fail'
+                    elif self.is_result_match(t['result'], self.SKIP_PATS):
+                        t['result'] = 'skip'
+                    else:
+                        t['result'] = 'unknown'
+                elif t['result'] in fixupdict:
+                    t['result'] = fixupdict[t['result']]
+                else:
+                    t['result'] = 'unknown'
+
+    def is_result_match(self, result, patterns=[]):
+        cap_result = string.upper(result)
+        for pattern in patterns:
+            cap_pattern = string.upper(pattern)
+            pat_index = string.find(cap_result, cap_pattern)
+            if pat_index > -1:
+                return True
+
+        return False
 
     def fixmeasurements(self):
         """Measurements are often read as strings, but need to be float
@@ -495,6 +521,14 @@
     def setadb(self, adb=None):
         self.adb = adb
 
+    def set_result_patterns(self, pass_pat=[], fail_pat=[], skip_pat=[]):
+        if pass_pat:
+            self.PASS_PATS = pass_pat
+        if fail_pat:
+            self.FAIL_PATS = fail_pat
+        if skip_pat:
+            self.SKIP_PATS = skip_pat
+
 
 def _run_steps_host(steps=[], serial=None, option=None, resultsdir=None):
     adb = ADB(serial)