Merge lp:~dooferlad/linaro-ci-cli/get-command into lp:linaro-ci-cli

[James Tunnicliffe]

Added bulk of CLI get command.

lci get
 - get status of all runs

lci get <job name>
 - get status of all runs of job

lci get <job name> <build number>
 - get status of single run. Includes listing of artefacts.

Once you have identified a build that you are interested in you can get 1/all files and the console output:
lci get <job name> <build number> --get-file <file name>
lci get <job name> <build number> --get-all-files
lci get <job name> <build number> --console

[Paul Sokolovsky (pfalcon)]

I wondered where these magic filenames come from:

63 + if file_name == "*console_url*":
64 + print ("Fetching console output (will be stored as %s)." %
65 + (output_file_name))
66 + elif file_name == "*zip*/archive.zip":

And then figured it's Jenkins URLs components to download corresponding things. But shouldn't we abstract them?

133 + # Error handling. If user has requested a file(s)/console but not
134 + # specified a build number this is an error.
135 + if parameters["get_file"]:
136 + raise CommandFailed(self.name,
137 + message="Unable to --get-file for more than one job")

Comment appear to be inconsistent with the error message - does the latter wants to say "Unable to get for more than one *build*"?

[Paul Sokolovsky (pfalcon)]

135 + if parameters["get_file"]:
138 + if parameters["get_all_files"]:
141 + if parameters["console"]:

Also, I'm all for useful and descriptive messages, but do we need to get *that* detailed? ("Unable to execute operation for more than one job/build" sounds pretty clear either.)

[Paul Sokolovsky (pfalcon)]

> if(len(job_data["list_artifacts"]) and

PEP8 beeps.

[Paul Sokolovsky (pfalcon)]

> +import simplejson

Why not standard json module?

[lp:~dooferlad/linaro-ci-cli/get-command]

25. By James Tunnicliffe on 2013-03-01

Monkey patch older requests libraries so they have a json function.

26. By James Tunnicliffe on 2013-03-06

Some code cleanups and added help text

27. By James Tunnicliffe on 2013-03-06

Fixed up get matching more than 1 build but no output requested

28. By James Tunnicliffe on 2013-03-06

Updated add command parameters to be more clear

29. By James Tunnicliffe on 2013-03-06

Improved status command

30. By James Tunnicliffe on 2013-03-07

Fixed up currnt/previous prints from status command

31. By James Tunnicliffe on 2013-03-11

"Cleaned up get Command._download_file code -- moved prints out into run function where there was already sensible places to put them
Fixed up tests.
Clean error when unable to contact server."
Made status command have a more useful output.

[James Tunnicliffe (dooferlad)]

Have addressed points brought up in review. There are a couple of
small changes made for the demo at Connect in this branch now as well
(commands/status.py has prettier printing, commands/base_command.py
catches connection errors and prints a user friendly message). I can
split them out into another merge if you like.

[Milo Casagrande (milo)]

Hey James,

forgot to update this. Looks good to go.
Thanks.

review: Approve

=== modified file 'commands/add.py'
--- commands/add.py	2013-02-11 15:21:35 +0000
+++ commands/add.py	2013-03-11 13:41:20 +0000
@@ -46,8 +46,10 @@
         # [--run]
         parser = argparse.ArgumentParser(description='Linaro CI: Add task.',
                                          prog=self.program_name)
-        parser.add_argument('vcs_url', type=str,
+        parser.add_argument('--vcs-url', type=str, required=True,
             help='URL to check out test configuration from.')
+        parser.add_argument('--name', type=str, required=True,
+                            help='Name of job')
         parser.add_argument('--file-name', type=str,
             default=defaults.FILE_NAME,
             help='Name of the configuration file.'
@@ -58,7 +60,6 @@
                  'Default is %s' % defaults.CLASS_NAME)
         parser.add_argument('--run', action='store_true',
             help='Enqueue job immediately')
-        parser.add_argument('--name', type=str)
 
         args = parser.parse_args(parameters)
         return vars(args)

=== modified file 'commands/base_command.py'
--- commands/base_command.py	2013-02-20 10:16:50 +0000
+++ commands/base_command.py	2013-03-11 13:41:20 +0000
@@ -21,7 +21,7 @@
 import requests
 import sys
 from urlparse import urljoin
-
+import json
 
 class BaseCommand(object):
     def __init__(self, settings, name):
@@ -46,9 +46,23 @@
 
         return url, params
 
+    def _json(self):
+        return self.json_data
+
     def get(self, url, in_params=None):
         url, params = self._prep_request(url, in_params)
-        return requests.get(url, params=params)
+        try:
+            request = requests.get(url, params=params)
+        except requests.exceptions.ConnectionError:
+            print >> sys.stderr, "Unable to connect to server."
+            exit(1)
+
+        # Monkey patch older requests objects so they have a json function.
+        if not hasattr(request, 'json'):
+            self.json_data = json.loads(request.content)
+            setattr(request, 'json', self._json)
+
+        return request
 
     def post(self, url, data, in_params=None):
         url, params = self._prep_request(url, in_params)
@@ -72,20 +86,26 @@
 
 
 class CommandFailed(Exception):
-    def __init__(self, command, params, response):
+    def __init__(self, command, params=None, response=None, message=None):
         self.command = command
         self.params = params
         self.response = response
+        self.message = message
 
     def __str__(self):
-        message = "An error occurred when executing the command %s" %\
+        message = "An error occurred when executing the command %s: " %\
                   self.command
 
-        message += "\nURL %s\nReason %s\nHeaders %s\n\n%s" % (
-            self.response.url,
-            self.response.reason,
-            self.response.headers,
-            self.response.text.decode("string-escape"),
-        )
+        if self.message:
+            message += self.message
+
+        else:
+            if self.response:
+                message += "\nURL %s\nReason %s\nHeaders %s\n\n%s" % (
+                    self.response.url,
+                    self.response.reason,
+                    self.response.headers,
+                    self.response.text.decode("string-escape"),
+                )
 
         return message

=== modified file 'commands/get.py'
--- commands/get.py	2013-02-07 12:19:48 +0000
+++ commands/get.py	2013-03-11 13:41:20 +0000
@@ -18,32 +18,161 @@
 # along with Linaro Image Tools.  If not, see <http://www.gnu.org/licenses/>.
 
 import requests
+import re
 from base_command import BaseCommandNeedsAuth, CommandFailed
 import argparse
+import shutil
+import urllib2
 
 """
 Defines the lci get command
 """
 
+
 class Command(BaseCommandNeedsAuth):
+    def _download_file(self, file_name, job_data, output_file_name=None):
+        """Download the requested file"""
+        if not output_file_name:
+            output_file_name = file_name
+
+        if file_name in job_data["get_build_result"]:
+            url = job_data["get_build_result"][file_name]
+
+            # Use urllib2 here, not requests because the version of requests
+            # that comes with Ubuntu 12.04 doesn't have the ability to download
+            # a request in small chunks. This urllib2 call avoids downloading
+            # the entire file into memory before writing it out to disk.
+            req = urllib2.urlopen(url)
+            with open(output_file_name, 'wb') as fp:
+                shutil.copyfileobj(req, fp)
+        else:
+            raise CommandFailed("get", "Requested file not found.")
+
     def run(self, args):
         parameters = self._args_to_params(args)
 
-        print "Get output of task with params %s" % parameters
-
-        r = self.get("get", parameters)
+        r = self.get("runs", parameters)
 
         if r.status_code != requests.codes.ok:
             raise CommandFailed(self.name, parameters, r)
 
+        if len(r.json()["objects"]) == 0 and parameters["loop__name"]:
+            # We searched for something and didn't find it.
+            raise CommandFailed(self.name, message="job or build not found")
+
+        if len(r.json()["objects"]) == 1:
+            # If user has requested data from a single job fetch it and exit.
+            # Note that if a job has a single build, you don't need to specify
+            # the build number - there is enough identifying information to
+            # use these commands.
+            job_data = r.json()["objects"][0]
+            done_something = False
+
+            if parameters["get_file"]:
+                print "Fetching", parameters["get_file"]
+                self._download_file(parameters["get_file"], job_data)
+                done_something = True
+
+            if parameters["get_all_files"]:
+                file_name = "%s_%s.zip" % (job_data["name"],
+                                           job_data["build_number"])
+                print "Fetching all files. Storing in", file_name
+                self._download_file("*zip*/archive.zip", job_data, file_name)
+                done_something = True
+
+            if parameters["console"]:
+                file_name = "%s_%s.txt" % (job_data["name"],
+                                           job_data["build_number"])
+                print ("Fetching console output (will be stored as %s)." %
+                       (file_name))
+                self._download_file("*console_url*", job_data, file_name)
+
+                # now print out the console
+                with open(file_name) as console:
+                    for line in console.readlines():
+                        print line,
+                done_something = True
+
+            if done_something:
+                # Now exit. Don't print job data when downloading.
+                return
+
+        elif (parameters["get_file"] or
+              parameters["get_all_files"] or
+              parameters["console"]):
+            # Error handling. If user has requested a file(s)/console but not
+            # specified a build number this is an error.
+            build_or_job = "build" if "build_number" in parameters else "job"
+            raise CommandFailed(self.name,
+                                message="Found more than one result for this"
+                                " %s. Unable to fetch requested output."
+                                % (build_or_job))
+
+        # If we have got this far the user has not requested a file(s) or
+        # console output so print a sensible amount of job status information.
+        sorted_jobs = sorted(r.json()["objects"],
+                             key=lambda job_data:
+                             job_data["name"] + str(job_data["build_number"]))
+
+        if not sorted_jobs:
+            print "No jobs found"
+            return
+
+        # Only print list of artifacts if we have identified a single build,
+        # else just print build number and status.
+        if parameters["loop__name"]:
+            data_format = "{build_number:12d} | {status:>8s}"
+        else:
+            data_format = "{name:20s} | {build_number:12d} | {status:>8s}"
+
+        headings = {
+            "name": "Job Name",
+            "build_number": "Build Number",
+            "status": "Status"
+        }
+
+        blank = {"name": "", "build_number": "", "status": ""}
+        heading_format = re.sub("d}", "s}", data_format)
+
+        if len(r.json()["objects"]) == 1:
+            print heading_format.format(**headings) + " | Artifacts"
+        else:
+            print heading_format.format(**headings)
+
+        for job_data in sorted_jobs:
+            line = data_format.format(**job_data)
+
+            # If user has requested a single build, pretty print artifact list.
+            if (len(job_data["list_artifacts"]) and
+                len(r.json()["objects"]) == 1):
+                # Print first file name on the end of the job info line
+                print line + " | " + job_data["list_artifacts"][0]
+
+                # Print remainder of file names 1 per line.
+                for file_name in job_data["list_artifacts"][1:]:
+                    print heading_format.format(**blank) +\
+                          " | " + file_name
+            else:
+                print line
+
     def _args_to_params(self, parameters):
         # lci get <job ID> [--console]
         parser = argparse.ArgumentParser(
             description='Linaro CI: get task output.',
             prog=self.program_name,)
-        parser.add_argument('job_id', type=str, help='Job ID.')
+        parser.add_argument('name', nargs='?', type=str, help='Job name')
+        parser.add_argument('build_number', nargs='?', type=int,
+                            help='Build number')
         parser.add_argument('--console', action='store_true',
                             help='Enqueue job immediately')
-
+        parser.add_argument('--get-file', type=str,
+                            help='Name of file to download')
+        parser.add_argument('--get-all-files', action='store_true',
+                            help='Download all files in a zip.')
         args = parser.parse_args(parameters)
-        return vars(args)
+        args = vars(args)
+
+        # Rename "name" to "loop__name" to match the filter format
+        args["loop__name"] = args["name"]
+        del(args["name"])
+        return args

=== modified file 'commands/status.py'
--- commands/status.py	2013-02-07 12:19:48 +0000
+++ commands/status.py	2013-03-11 13:41:20 +0000
@@ -20,7 +20,7 @@
 import requests
 from base_command import BaseCommandNeedsAuth, CommandFailed
 import argparse
-import sys, os
+import re
 
 """
 Defines the lci status command
@@ -29,20 +29,59 @@
 class Command(BaseCommandNeedsAuth):
     def run(self, args):
         parameters = self._args_to_params(args)
-        r = self.get("loops", parameters)
-
-        if r.status_code != requests.codes.ok:
-            raise CommandFailed(self.name, parameters, r)
-
-        print "Status of %s" % parameters
-        print r.json()
+
+        jobs = self.get("loops", parameters)
+        if jobs.status_code != requests.codes.ok:
+            raise CommandFailed(self.name, parameters, jobs)
+        jobs = jobs.json()["objects"]
+
+        runs = self.get("runs", parameters)
+        if runs.status_code != requests.codes.ok:
+            raise CommandFailed(self.name, parameters, runs)
+        runs = runs.json()["objects"]
+
+        data_format = "{name:20s} | {builds:12d} | {status:>8s}"
+        headings = {
+            "name": "Job Name",
+            "builds": "Builds",
+            "status": "Status"
+        }
+
+        heading_format = re.sub("d}", "s}", data_format)
+
+        print heading_format.format(**headings)
+
+        for job in jobs:
+            name = job["name"]
+
+            builds = 0
+            status = "not run"
+            old_status = ""
+            for run in runs:
+                if run["name"] == name:
+                    if run["build_number"] > builds:
+                        builds = run["build_number"]
+                        status = run["status"]
+                    elif run["build_number"] == builds - 1:
+                        old_status = run["status"]
+
+            if status in ["unscheduled", "scheduled", "running"]:
+                status = old_status + " (build " + status + ")"
+
+            data = {
+                "name": name,
+                "builds": builds,
+                "status": status
+            }
+
+            print data_format.format(**data)
 
     def _args_to_params(self, parameters):
         # lci status <job ID> [--group] %s [--user] %s [--job-name] %s
         parser = argparse.ArgumentParser(
             prog=self.program_name,
             description='Linaro CI: get task output.')
-        parser.add_argument('--job-id', type=str, help='Job ID.')
+        parser.add_argument('--name', type=str, help='Job Name.')
         parser.add_argument('--user', type=str, help='User owning job.')
         parser.add_argument('--group', type=str, help='Group owning job.')
         parser.add_argument('--job-name', type=str, help='Job name.')

=== modified file 'commands/tests/test_add.py'
--- commands/tests/test_add.py	2013-02-11 16:13:12 +0000
+++ commands/tests/test_add.py	2013-03-11 13:41:20 +0000
@@ -63,7 +63,7 @@
 
         # Now we run an add command with the following arguments...
         args = [
-            "vcsurl",
+            "--vcs-url", "vcsurl",
             "--name", "jobname",
             ]
 

=== added file 'commands/tests/test_get.py'
--- commands/tests/test_get.py	1970-01-01 00:00:00 +0000
+++ commands/tests/test_get.py	2013-03-11 13:41:20 +0000
@@ -0,0 +1,347 @@
+# Copyright (C) 2013 Linaro
+#
+# Author: James Tunnicliffe <[e-mail]>
+#
+# This file is part of Linaro CI CLI.
+#
+# Linaro CI CLI is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Linaro CI CLI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Linaro Image Tools.  If not, see <http://www.gnu.org/licenses/>.
+
+from copy import copy
+import unittest
+from commands.defaults import (
+    CI_SERVER,
+    API_PREFIX,
+    )
+import commands.login
+import commands.get
+from mock import patch, MagicMock
+from test_utilities import FakeRequest, expectedUrl, NetworkingMockMixin
+from StringIO import StringIO
+import re
+
+
+class TestGetCommand(unittest.TestCase, NetworkingMockMixin):
+    def setUp(self):
+        # Monkey patch the raw_input function imported by login
+        self.fake_input = self.FakeRawInputLogin()
+        commands.login.raw_input = self.fake_input.raw_input_response
+
+        self.login_details = {"username": "me",
+                              "api_key": "12qwaszx"}
+        self.server_details = {"ci_server": CI_SERVER,
+                               "api_prefix": API_PREFIX}
+        self.settings = copy(self.server_details)
+        self.settings.update(self.login_details)
+
+        self.data_format = "{build_number:12d} | {status:>8s}"
+        self.data_format_with_name = "{name:20s} | " + self.data_format
+        self.heading_format = re.sub("d}", "s}", self.data_format)
+        self.heading_format_with_name = "{name:20s} | " + self.heading_format
+        self.headings = {
+            "name": "Job Name",
+            "build_number": "Build Number",
+            "status": "Status"
+        }
+        self.empty_line = {
+            "name": "",
+            "build_number": "",
+            "status": ""
+        }
+
+
+    def tearDown(self):
+        # Restore the original raw_input
+        commands.login.raw_input = raw_input
+
+    def _login(self, mock_requests_get):
+        # get command requires authentication so login is triggered. We pass an
+        # empty username and api_key, forcing a prompt for those values.
+        get_cmd = commands.get.Command(copy(self.settings), "test_logged_in")
+
+        self.assertEqual(expectedUrl("login_test"),
+                         mock_requests_get.call_args[0][0])
+        self.assertDictContainsSubset(self.login_details,
+                                      mock_requests_get.call_args[1]["params"])
+
+        return get_cmd
+
+    def _check_call_params(self, mock_requests_get):
+        self.assertEqual(expectedUrl("runs"),
+                         mock_requests_get.call_args[0][0])
+        self.assertDictContainsSubset(self.login_details,
+                                      mock_requests_get.call_args[1]["params"])
+
+    def _heading_line(self):
+        if self.args:
+            heading = self.heading_format.format(**self.headings)
+        else:
+            heading = self.heading_format_with_name.format(**self.headings)
+
+        if len(self.job_data["objects"]) == 1:
+            heading += " | Artifacts"
+
+        return heading
+
+    def _data_lines(self):
+        lines = []
+        sorted_jobs = sorted(self.job_data["objects"],
+                             key=lambda job_data:
+                             job_data["name"] + str(job_data["build_number"]))
+        for data in sorted_jobs:
+            if self.args:
+                line_format = self.data_format
+                heading_format = self.heading_format
+            else:
+                line_format = self.data_format_with_name
+                heading_format = self.heading_format_with_name
+
+            lines.append(line_format.format(**data))
+            if len(self.job_data["objects"]) == 1:
+                if "list_artifacts" in data:
+                    lines[-1] += " | " + data["list_artifacts"][0]
+
+                    if len(data["list_artifacts"]) > 1:
+                        for file_name in data["list_artifacts"][1:]:
+                            lines.append(
+                                heading_format.format(**self.empty_line) +
+                                " | " + file_name)
+
+        return lines
+
+    @property
+    def expected(self):
+        return [self._heading_line()] + self._data_lines()
+
+    @patch('sys.stdout')
+    @patch('requests.get')
+    def test_get_empty_job_list(self, mock_requests_get, mock_stdout):
+        my_stdout = StringIO()
+        mock_stdout.write = my_stdout.write
+        mock_requests_get.return_value = FakeRequest(200)
+        mock_requests_get.return_value.set_json({
+            "objects": []
+        })
+
+        # Login, get the command object
+        get_cmd = self._login(mock_requests_get)
+
+        # Now we run a get command with the following arguments...
+        args = []
+        get_cmd.run(args)
+
+        # Check that the URLs used in the REST query look sane
+        self._check_call_params(mock_requests_get)
+
+        # Check command output
+        self.assertEqual("No jobs found\n", my_stdout.getvalue())
+
+    @patch('sys.stdout')
+    @patch('requests.get')
+    def _test_get(self, mock_requests_get, mock_stdout):
+        my_stdout = StringIO()
+        mock_stdout.write = my_stdout.write
+        mock_requests_get.return_value = FakeRequest(200)
+        mock_requests_get.return_value.set_json(self.job_data)
+
+        # Login, get the command object
+        get_cmd = self._login(mock_requests_get)
+
+        # Now we run a get command with the following arguments...
+        get_cmd.run(self.args)
+
+        # Check that the URLs used in the REST query look sane
+        self._check_call_params(mock_requests_get)
+
+        # Check command output
+        printed = my_stdout.getvalue().splitlines()
+        self.assertEqual(self.expected, printed)
+
+    def test_get_single_job_single_run(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file"]
+                }
+            ]
+        }
+
+        self.args = []
+        self._test_get()
+
+    def test_get_single_job_single_run_many_files(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file", "AnotherFile.txt", ".foo"]
+                }
+            ]
+        }
+
+        self.args = []
+        self._test_get()
+
+    def test_get_single_job_two_runs(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file"]
+                },
+                {
+                    "name": "a name",
+                    "build_number": 2,
+                    "status": "passed",
+                    "list_artifacts": ["a_file"]
+                }
+            ]
+        }
+
+        self.args = []
+        self._test_get()
+
+    def test_get_two_jobs_two_runs(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a job",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file"]
+                },
+                {
+                    "name": "another job",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file"]
+                }
+            ]
+        }
+
+        self.args = []
+        self._test_get()
+
+    def test_get_many_jobs_many_runs(self):
+        self.job_data = {
+            "objects": []
+        }
+
+        for job_name in ["job1", "job2", "another job", "YetAnother Job!"]:
+            for counter in range(1, 30):
+                self.job_data["objects"].append({
+                    "name": job_name,
+                    "build_number": counter,
+                    "status": "passed",
+                    "list_artifacts": ["a_file", "SomeFile.txt", ".hide"]
+                })
+
+        self.args = []
+        self._test_get()
+
+    @patch('sys.stdout')
+    @patch('requests.get')
+    @patch('urllib2.urlopen')
+    @patch('shutil.copyfileobj')
+    def _test_download_file(self, expected_file, expected_url,
+            copyfileobj, urlopen, mock_requests_get, mock_stdout):
+
+        my_stdout = StringIO()
+        mock_stdout.write = my_stdout.write
+        mock_requests_get.return_value = FakeRequest(200)
+        mock_requests_get.return_value.set_json(self.job_data)
+
+        # Login, get the command object
+        get_cmd = self._login(mock_requests_get)
+
+        mock_open = MagicMock()
+        with patch('__builtin__.open', mock_open):
+            # The easiest way to patch readlines is like this...
+            with open("some_file") as some_file:
+                some_file.readlines = MagicMock()
+                some_file.readlines.return_value = []
+
+            # Run the command under test
+            get_cmd.run(self.args)
+
+            # Check that the URLs used in the REST query look sane
+            self._check_call_params(mock_requests_get)
+
+            # Check the URL we downloaded from and the file we wrote to
+            self.assertEqual(mock_open.call_args[0], expected_file)
+            self.assertEqual(urlopen.call_args[0], (expected_url,))
+
+    def test_get_single_job_download_single_file(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file", "AnotherFile.txt", ".foo"],
+                    "get_build_result": {"a_file": "a_file_url"}
+                }
+            ]
+        }
+
+        self.args = ["--get-file", "a_file"]
+
+        self._test_download_file(("a_file", "wb"), "a_file_url")
+
+    def test_get_single_job_download_all_files(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file", "AnotherFile.txt", ".foo"],
+                    "get_build_result": {"a_file": "a_file_url",
+                                         "*zip*/archive.zip": "all_files_url",
+                                         "*console_url*": "console_url"}
+                }
+            ]
+        }
+
+        self.args = ["--get-all-files"]
+
+        self._test_download_file(("a name_1.zip", "wb"), "all_files_url")
+
+    def test_get_single_job_download_console(self):
+        self.job_data = {
+            "objects": [
+                {
+                    "name": "a name",
+                    "build_number": 1,
+                    "status": "passed",
+                    "list_artifacts": ["a_file", "AnotherFile.txt", ".foo"],
+                    "get_build_result": {"a_file": "a_file_url",
+                                         "*zip*/archive.zip": "all_files_url",
+                                         "*console_url*": "console_url"}
+                }
+            ]
+        }
+
+        self.args = ["--console"]
+
+        self._test_download_file(("a name_1.txt",), "console_url")
+
+if __name__ == '__main__':
+    unittest.main()

=== modified file 'commands/tests/test_utilities.py'
--- commands/tests/test_utilities.py	2013-02-11 16:13:12 +0000
+++ commands/tests/test_utilities.py	2013-03-11 13:41:20 +0000
@@ -37,6 +37,12 @@
         else:
             return self.return_codes
 
+    def set_json(self, dictionary):
+        self.json_dict = dictionary
+
+    def json(self):
+        return self.json_dict
+
 def expectedUrl(location):
     url = urlparse.urljoin(CI_SERVER, API_PREFIX + location)
     if url[-1] != "/":

=== modified file 'lci'
--- lci	2013-02-07 12:19:48 +0000
+++ lci	2013-03-11 13:41:20 +0000
@@ -101,12 +101,13 @@
     print """Linaro CI CLI -- interact with the Linaro CI service.
 http://ci.linaro.org/
 
-Commands:
-...
+Basic commands:
+  lci login          Login to web service
+  lci add            Add a job to the CI service
+  lci get            Get output from a run of a job
+  lci run            Run a job
+  lci status         Get status of configured jobs and runs
 """
-    # TODO: Should above import all commands and print info string from each?
-    # TODO: Can we construct this with argparse from lots of commands?
-
 
 if __name__ == "__main__":
     logging.basicConfig(format='%(message)s', level=logging.WARNING)