Merge lp:~fginther/cupstream2distro-config/stack-lookup-3 into lp:cupstream2distro-config

[Francis Ginther]

Provides an API and a utility to query a stack for project, job names and attributes.

Provides an API and a utility to query a stack for project, job names and attributes.

This will be used by the dashboard (it's currently using an earlier version).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:424
http://jenkins.qa.ubuntu.com/job/cupstream2distro-config-ci/305/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/cupstream2distro-config-saucy-amd64-ci/103

Click here to trigger a rebuild:
http://s-jenkins:8080/job/cupstream2distro-config-ci/305/rebuild

review: Approve (continuous-integration)

[Chris Gagnon (chris.gagnon)]

the cli options -d and -b need tests

[Chris Gagnon (chris.gagnon)]

I am trying to lookup a children in a stack and get the following

./cu2d-stack-lookup -l -a -i ../stacks/phablet/qt.cfg
["qt-folks", "qtubuntu-gps"]
2013-06-19 17:07:21,049 ERROR Could not find None in stack configuration

[Chris Gagnon (chris.gagnon)]

I get the same error without the i
./cu2d-stack-lookup -l ../stacks/phablet/qt.cfg -a
["qt-folks", "qtubuntu-gps"]
2013-06-19 17:20:38,097 ERROR Could not find None in stack configuration

[Chris Gagnon (chris.gagnon)]

I get an error when using -t with -l

./cu2d-stack-lookup -t qt-folks -l ../stacks/phablet/qt.cfg
["qt-folks", "qtubuntu-gps"]
2013-06-19 17:24:58,095 ERROR Could not find qt-folks in stack configuration

[Chris Gagnon (chris.gagnon)]

review: Needs Fixing

[Francis Ginther (fginther)]

I'm going to rework this due to a change in direction from the dashboard project. We can't install this in the production environment. My solution is to add a utility to post the information to a well known jenkins job so that the dashboard can consume the data directly from jenkins.

[lp:~fginther/cupstream2distro-config/stack-lookup-3]

425. By Francis Ginther on 2013-07-16

Add option to choose output format (yaml or json) and an option to dump a stack summary (to be used by the dashboard tools).

426. By Francis Ginther on 2013-07-16

Changed project list to a dictionary and fixed error caused by an empty project list.

[Loïc Minier (lool)]

(Rejecting to drop out of active reviews)

Unmerged revisions

426. By Francis Ginther on 2013-07-16

Changed project list to a dictionary and fixed error caused by an empty project list.

425. By Francis Ginther on 2013-07-16

Add option to choose output format (yaml or json) and an option to dump a stack summary (to be used by the dashboard tools).

424. By Francis Ginther on 2013-06-14

Provides an API and a utility to query a stack for project, job names and attributes.

=== added file 'c2dconfigutils/cu2dStackLookup.py'
--- c2dconfigutils/cu2dStackLookup.py	1970-01-01 00:00:00 +0000
+++ c2dconfigutils/cu2dStackLookup.py	2013-07-16 19:36:23 +0000
@@ -0,0 +1,247 @@
+"""Supply information about projects and job names within a stack
+
+- Reads stack configuration from YAML configuration file
+- Returns list of projects within a stack, job names for a project or
+  specific attributes of a project
+
+"""
+# Copyright (C) 2013, Canonical Ltd (http://www.canonical.com/)
+#
+# Author: Francis Ginther <[e-mail]>
+#
+# This software 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.
+#
+# This software 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 this software.  If not, see <http://www.gnu.org/licenses/>.
+
+import argparse
+import copy
+import logging
+import json
+import os.path
+import yaml
+
+from c2dconfigutils import (
+    dict_union, load_default_cfg, load_stack_cfg, set_logging,
+    get_ci_base_job_name)
+
+
+class StackLookup(object):
+
+    DEFAULT_BASE_PATH = '/usr/share/cupstream2distro-config/ci'
+    SUPPORTED_FORMATS = ['json', 'yaml']
+    STACK_KEYS = ['name', 'series', 'ppa', 'dest']
+
+    def parse_arguments(self, base_path):
+        """Parses the command line arguments
+
+        return args: the parsed arguments
+        """
+        parser = argparse.ArgumentParser(
+            description='Generates jenkins job names from a stack')
+        parser.add_argument('-d', '--debug', action='store_true',
+                            default=False, help='enable debug mode')
+        parser.add_argument('-b', '--base_path',
+                            default=base_path,
+                            help='path to the cupstream2distro-config '
+                            'base directory (default: %s)' % base_path)
+        parser.add_argument('-o', '--output-format',
+                            default='yaml',
+                            help='Output format to use {}'.format(
+                            self.SUPPORTED_FORMATS))
+        parser.add_argument('-s', '--summary', action='store_true',
+                            help='Return a stack dump summary')
+        parser.add_argument('-l', '--list-projects', action='store_true',
+                            default=False, help='return a list of projects '
+                            'defined within the stack.')
+        parser.add_argument('-p', '--project',
+                            help='Reference the given project')
+        parser.add_argument('-a', '--autoland', action='store_true',
+                            default=False,
+                            help='Return the autolanding jobs for a project')
+        parser.add_argument('-c', '--ci', action='store_true',
+                            default=False,
+                            help='Return the ci jobs for a project')
+        parser.add_argument('-t', '--attribute',
+                            help='Return the value of the given attribute')
+        parser.add_argument('-i', '--children', action='store_true',
+                            default=False,
+                            help='Return the child jobs for a project '
+                            '(requires -c/--ci or -a/--autolanding)')
+        parser.add_argument('stackcfg',
+                            help='Path to a configuration file for the stack')
+        args = parser.parse_args()
+        if (not args.list_projects and args.project is None and
+            not args.summary):
+            parser.error('Must specify one of -l/--list-projects, '
+                         '-s/--summary or -p/--project')
+            return False
+        if (args.project and (args.attribute is None and not args.ci and
+                              not args.autoland)):
+            parser.error('Must specify -a/--autolanding, -c/--ci or '
+                         '-t/--attribute with -p/--project')
+            return False
+        if (args.children and (not args.ci and not args.autoland)):
+            parser.error('Must specify -a/--autolanding or -c/--ci with '
+                         '-i/--children')
+            return False
+        if args.output_format not in self.SUPPORTED_FORMATS:
+            parser.error('Output format must be one of: {}'.format(
+                self.SUPPORTED_FORMATS))
+        return args
+
+    def _generate_name(self, project_name, project_config, job_type, children):
+        job_base_name = get_ci_base_job_name(project_name, project_config)
+        if children and 'configurations' in project_config:
+            names = list()
+            configurations = project_config.pop('configurations')
+            for config_name in configurations:
+                if not configurations[config_name]:
+                    # configuration is explicitly removed
+                    continue
+                names.append('-'.join([job_base_name, config_name, job_type]))
+            return names
+        return ['-'.join([job_base_name, job_type])]
+
+    def _prepare_project(self, stack, project_name, job_type):
+        if project_name not in stack['projects']:
+            raise KeyError
+        project_config = copy.deepcopy(stack['ci_default'])
+        dict_union(project_config, stack['projects'][project_name])
+        job_only_dict = dict()
+        if job_type in project_config:
+            job_only_dict = project_config.pop(job_type)
+        if project_config.get('%s_template' % (job_type), False):
+            job_dict = copy.deepcopy(project_config)
+            if job_only_dict is not None:
+                dict_union(job_dict, job_only_dict)
+                return job_dict
+        return None
+
+    def _get_name(self, stack, project_name, job_type, children):
+        try:
+            job_dict = self._prepare_project(stack, project_name, job_type)
+        except KeyError:
+            return False
+        if job_dict:
+            return self._generate_name(project_name, job_dict, job_type, children)
+        return list()
+
+    def get_projects(self, stack):
+        return sorted([project for project in stack['projects']])
+
+    def get_ci_name(self, stack, project, children=False):
+        return self._get_name(stack, project, 'ci', children)
+
+    def get_autolanding_name(self, stack, project, children=False):
+        return self._get_name(stack, project, 'autolanding', children)
+
+    def get_attribute(self, stack, project_name, job_type, attribute):
+        try:
+            project = self._prepare_project(stack, project_name, job_type)
+        except KeyError:
+            return False
+        if attribute == 'target_branch' and 'target_branch' not in project:
+            value = "lp:" + project_name
+        else:
+            value = project[attribute]
+        return value
+
+    def dump_stack(self, file_name, stack):
+        out_data = {'projects': {}}
+
+        # Try to determine the following pieces from the file name
+        (head, out_data['file_name']) = os.path.split(file_name)
+        (head, out_data['release']) = os.path.split(head)
+        for key in stack:
+            data = stack[key]
+            if key in self.STACK_KEYS:
+                out_data[key] = data
+
+        if 'projects' in stack and stack['projects']:
+            for project in stack['projects']:
+                config = {}
+                config['target_branch'] = self.get_attribute(stack, project,
+                                                             'autolanding',
+                                                             'target_branch')
+                config['ci'] = self.get_ci_name(stack, project)[0]
+                config['autolanding'] = self.get_autolanding_name(stack,
+                                                                  project)[0]
+                out_data['projects'][project] = config
+
+        return out_data
+
+    def output(self, output_format, data):
+        if output_format == 'json':
+            return json.dumps(data)
+        if output_format == 'yaml':
+            return yaml.dump(data)
+        raise RuntimeError('Unknown output format')
+
+    def __call__(self, default_config_path):
+        """Entry point for cu2d-stack-info"""
+        args = self.parse_arguments(default_config_path)
+        if not args:
+            return 1
+
+        set_logging(args.debug)
+        default_config = load_default_cfg(args.base_path)
+        stackcfg = load_stack_cfg(args.stackcfg, default_config)
+        if not stackcfg:
+            logging.error('Stack configuration failed to load. Aborting!')
+            return 1
+        if 'projects' not in stackcfg:
+            logging.error('No projects found in stack configuration')
+            return 1
+
+        if args.list_projects:
+            projects = self.get_projects(stackcfg)
+            if not projects:
+                return 1
+            print(self.output(args.output_format, sorted(projects)))
+
+        if args.summary:
+            data_dump = self.dump_stack(args.stackcfg, stackcfg)
+            if not data_dump:
+                return 1
+            print(self.output(args.output_format, data_dump))
+
+        if args.attribute:
+            job_type = 'autolanding'
+            if args.ci:
+                job_type = 'ci'
+            value = self.get_attribute(stackcfg, args.project, job_type,
+                                       args.attribute)
+            if not value:
+                logging.error("Could not find %s in stack configuration" %
+                              args.attribute)
+                return 1
+            print(self.output(args.output_format, value))
+            return 0
+
+        if args.ci:
+            name = self.get_ci_name(stackcfg, args.project, args.children)
+            if not name:
+                logging.error("Could not find %s in stack configuration" %
+                              args.project)
+                return 1
+            print(self.output(args.output_format, name))
+            return 0
+
+        if args.autoland:
+            name = self.get_autolanding_name(stackcfg, args.project,
+                                             args.children)
+            if not name:
+                logging.error("Could not find %s in stack configuration" %
+                              args.project)
+                return 1
+            print(self.output(args.output_format, name))
+        return 0
 
=== added file 'ci/cu2d-stack-lookup'
--- ci/cu2d-stack-lookup	1970-01-01 00:00:00 +0000
+++ ci/cu2d-stack-lookup	2013-07-16 19:36:23 +0000
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+"""Supply information about projects and job names within a stack
+
+- Reads stack configuration from YAML configuration file
+- Returns list of projects within a stack, jobs names for a project or
+  specific attributes of a project
+
+"""
+# Copyright (C) 2013, Canonical Ltd (http://www.canonical.com/)
+#
+# Author: Francis Ginther <[e-mail]>
+#
+# This software 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.
+#
+# This software 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 this software.  If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+
+BASEDIR = os.path.dirname(__file__)
+
+# add local c2configutils
+if os.path.isdir(os.path.join(BASEDIR, '../c2dconfigutils')):
+    sys.path.insert(0, os.path.join(BASEDIR, '..'))
+
+from c2dconfigutils.cu2dStackLookup import StackLookup
+
+
+if __name__ == "__main__":
+    command = StackLookup()
+    sys.exit(command(BASEDIR))
 
=== added file 'tests/test_cu2dStackLookup.py'
--- tests/test_cu2dStackLookup.py	1970-01-01 00:00:00 +0000
+++ tests/test_cu2dStackLookup.py	2013-07-16 19:36:23 +0000
@@ -0,0 +1,455 @@
+from unittest import TestCase
+from mock import patch, MagicMock
+from StringIO import StringIO
+import sys
+
+from c2dconfigutils.cu2dStackLookup import (
+    StackLookup)
+
+
+class Cu2dStackLookupTestsBase(TestCase):
+
+    def setUp(self):
+        self.stack = {
+            'ci_default': {
+                'ci_template': 'ci-config.xml.tmpl',
+                'autolanding_template': 'autolanding-config.xml.tmpl',
+                'build_template': 'pbuilder-config.xml.tmpl',
+                'ci': {
+                    'configurations': {
+                        'raring-amd64': {
+                            'node_label': 'pbuilder'},
+                        'raring-i386': {
+                            'node_label': 'pbuilder'}}}},
+            'projects': {
+                'autopilot': {
+                    'autolanding': {
+                        'configurations': {
+                            'quantal-amd64': {
+                                'node_label': 'pbuilder'},
+                            'quantal-i386': {
+                                'node_label': 'pbuilder'}}}},
+                'autopilot-qt': {
+                    'ci_template': False},
+                'autopilot-gtk': {
+                    'autolanding_template': False},
+                'xpathselect': {
+                    'target_branch': 'lp:xpathselect/feature',
+                    'ci': {
+                        'configurations': {
+                            'raring-amd64': False}}}}}
+        self.lookup = StackLookup()
+
+
+class Cu2dStackLookupMethodTests(Cu2dStackLookupTestsBase):
+
+    def test_get_projects(self):
+        """Verifies all project names are returned"""
+        expected = ['autopilot', 'autopilot-gtk', 'autopilot-qt',
+                    'xpathselect']
+        actual = self.lookup.get_projects(self.stack)
+        self.assertEqual(expected, actual)
+
+    def test_get_name_ci(self):
+        """Verifies a ci name is generated"""
+        expected = ['autopilot-ci']
+        actual = self.lookup._get_name(self.stack, 'autopilot', 'ci', False)
+        self.assertEqual(expected, actual)
+
+    def test_get_name_autolanding(self):
+        """Verifies an autolanding name is generated"""
+        expected = ['autopilot-autolanding']
+        actual = self.lookup._get_name(self.stack, 'autopilot', 'autolanding',
+                                       False)
+        self.assertEqual(expected, actual)
+
+    def test_get_name_target_branch(self):
+        """Verifies a name is generated based on the target branch"""
+        expected = ['xpathselect-feature-ci']
+        actual = self.lookup._get_name(self.stack, 'xpathselect', 'ci', False)
+        self.assertEqual(expected, actual)
+
+    def test_get_name_no_template(self):
+        """Verifies that no names are returned from a False template"""
+        expected = []
+        actual = self.lookup._get_name(self.stack, 'autopilot-qt', 'ci', False)
+        self.assertEqual(expected, actual)
+
+    def test_get_name_not_found(self):
+        """Verifies an invalid project returns no names"""
+        expected = False
+        actual = self.lookup._get_name(self.stack, 'not-found', 'ci', False)
+        self.assertEqual(expected, actual)
+
+    def test_get_ci_name(self):
+        """Verifies a ci job is returned for a valid project"""
+        expected = ['autopilot-gtk-ci']
+        actual = self.lookup.get_ci_name(self.stack, 'autopilot-gtk')
+        self.assertEqual(expected, actual)
+
+    def test_get_ci_children(self):
+        """Verifies ci children jobs are returned for a valid project"""
+        expected = ['autopilot-raring-amd64-ci',
+                    'autopilot-raring-i386-ci']
+        actual = self.lookup.get_ci_name(self.stack, 'autopilot',
+                                         children=True)
+        self.assertEqual(expected, actual)
+
+    def test_get_ci_children_default_removed(self):
+        """Verifies a project can overide a default configuration"""
+        expected = ['xpathselect-feature-raring-i386-ci']
+        actual = self.lookup.get_ci_name(self.stack, 'xpathselect',
+                                         children=True)
+        self.assertEqual(expected, actual)
+
+    def test_get_autolanding_name(self):
+        """Verifies an autolanding job is returned for a valid project"""
+        expected = ['autopilot-autolanding']
+        actual = self.lookup.get_autolanding_name(self.stack, 'autopilot')
+        self.assertEqual(expected, actual)
+
+    def test_get_autolanding_children(self):
+        """Verifies autolanding children are returned for a valid project"""
+        expected = ['autopilot-quantal-i386-autolanding',
+                    'autopilot-quantal-amd64-autolanding']
+        actual = self.lookup.get_autolanding_name(self.stack, 'autopilot',
+                                                  children=True)
+        self.assertEqual(expected, actual)
+
+    def test_get_autolanding_children_no_template(self):
+        """Verifies that no children are returned from a False template"""
+        expected = []
+        actual = self.lookup.get_autolanding_name(self.stack, 'autopilot-gtk',
+                                                  children=True)
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_default_target_branch(self):
+        """Verifies the default target branch is returned"""
+        expected = 'lp:autopilot'
+        actual = self.lookup.get_attribute(self.stack, 'autopilot',
+                                           'autolanding', 'target_branch')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_target_branch(self):
+        """Verifies the stack specified target branch is returned"""
+        expected = 'lp:xpathselect/feature'
+        actual = self.lookup.get_attribute(self.stack, 'xpathselect', 'ci',
+                                           'target_branch')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_autolanding_value(self):
+        """Verifies the autolanding attribute value is returned"""
+        expected = {
+            'quantal-amd64': {
+                'node_label': 'pbuilder'},
+            'quantal-i386': {
+                'node_label': 'pbuilder'}}
+        actual = self.lookup.get_attribute(self.stack, 'autopilot',
+                                           'autolanding', 'configurations')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_ci_value(self):
+        """Verifies the ci attribute value is returned"""
+        expected = {
+            'raring-amd64': {
+                'node_label': 'pbuilder'},
+            'raring-i386': {
+                'node_label': 'pbuilder'}}
+        actual = self.lookup.get_attribute(self.stack, 'autopilot',
+                                           'ci', 'configurations')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_bad_project(self):
+        """Verifies that a missing project returns False"""
+        expected = False
+        actual = self.lookup.get_attribute(self.stack, 'bad_project',
+                                           'ci', 'bad_key')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_bad_value(self):
+        """Verifies that a missing key raises a KeyError"""
+        with self.assertRaises(KeyError):
+            self.lookup.get_attribute(self.stack, 'autopilot', 'ci',
+                                      'bad_key')
+
+
+class Cu2dStackLookupCallTests(Cu2dStackLookupTestsBase):
+
+    def setUp(self):
+        super(Cu2dStackLookupCallTests, self).setUp()
+        self.args = type('Args', (object,), {'debug': False,
+                                             'base_path': '/tmp',
+                                             'list_projects': False,
+                                             'project': None,
+                                             'autoland': False,
+                                             'ci': False,
+                                             'attribute': None,
+                                             'children': False,
+                                             'stackcfg': 'stack.cfg'})
+        self.lookup.parse_arguments = lambda x: self.args
+        self.saved_stdout = sys.stdout
+        self.stdout = StringIO()
+        sys.stdout = self.stdout
+
+    def tearDown(self):
+        sys.stdout = self.saved_stdout
+
+    def test_bad_args(self):
+        """Verifies error return for invalid arguments"""
+        expected = 1
+        self.args = None
+        actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_no_stack(self):
+        """Verifies error return for an invalid stack file"""
+        expected = 1
+        self.args.list_projects = True
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: {}):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_no_projects(self):
+        """Verifies error return for a stack file with no projects"""
+        expected = 1
+        self.args.list_projects = True
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: {'ci_default': {}}):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_get_projects(self):
+        """Verifies output for a project list request"""
+        expected = 0
+        self.args.list_projects = True
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+        output = '["autopilot", "autopilot-gtk", "autopilot-qt", ' \
+                 '"xpathselect"]'
+        self.assertEqual(output, self.stdout.getvalue().strip())
+
+    def test_get_projects_none_found(self):
+        """Verifies error return when stack file contains no projects"""
+        expected = 1
+        self.args.list_projects = True
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: {'projects': {}}):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_get_attribute_ci(self):
+        """Verifies output for an attribute request"""
+        expected = 0
+        self.args.attribute = 'target_branch'
+        self.args.ci = True
+        self.args.project = 'xpathselect'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+        output = '"lp:xpathselect/feature"'
+        self.assertEqual(output, self.stdout.getvalue().strip())
+
+    def test_get_attribute_autoland(self):
+        """Verifies out for an attribute request for an autolanding job"""
+        expected = 0
+        self.args.attribute = 'target_branch'
+        self.args.project = 'xpathselect'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+        output = '"lp:xpathselect/feature"'
+        self.assertEqual(output, self.stdout.getvalue().strip())
+
+    def test_get_attribute_no_project(self):
+        """Verifies error return when the project is not found"""
+        expected = 1
+        self.args.attribute = 'target_branch'
+        self.args.project = 'not-found'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_get_ci_name(self):
+        """Verifies output for a ci job list request"""
+        expected = 0
+        self.args.ci = True
+        self.args.project = 'autopilot'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+        output = '["autopilot-ci"]'
+        self.assertEqual(output, self.stdout.getvalue().strip())
+
+    def test_get_ci_name_no_project(self):
+        """Verifies error return when the project is not found"""
+        expected = 1
+        self.args.ci = True
+        self.args.project = 'not-found'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+    def test_get_autolanding_name(self):
+        """Verifies output for an autolanding job list request"""
+        expected = 0
+        self.args.autoland = True
+        self.args.project = 'autopilot'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+        output = '["autopilot-autolanding"]'
+        self.assertEqual(output, self.stdout.getvalue().strip())
+
+    def test_get_autolanding_name_no_project(self):
+        """Verifies error return when the project is not found"""
+        expected = 1
+        self.args.autoland = True
+        self.args.project = 'not-found'
+        with patch('c2dconfigutils.cu2dStackLookup.load_default_cfg',
+                   new=lambda x: True), \
+                patch('c2dconfigutils.cu2dStackLookup.load_stack_cfg',
+                      new=lambda x, y: self.stack):
+            actual = self.lookup('/tmp')
+        self.assertEqual(expected, actual)
+
+
+class TestParseArguments(TestCase):
+    def setUp(self):
+        self.error_mock = MagicMock()
+
+    def test_gibberish(self):
+        """Verifies invalid arguments returns an error"""
+        sys_argv = ['./command', '-oheck']
+        with patch('sys.argv', sys_argv):
+            with patch('argparse.ArgumentParser.error', self.error_mock):
+                lookup = StackLookup()
+                lookup.parse_arguments('')
+                self.error_mock.assert_any_call(
+                    'too few arguments')
+
+    def test_noparams(self):
+        """Verifies no arguments returns a too few arguments error"""
+        sys_argv = ['./command']
+        with patch('sys.argv', sys_argv):
+            with patch('argparse.ArgumentParser.error', self.error_mock):
+                lookup = StackLookup()
+                lookup.parse_arguments('')
+                self.error_mock.assert_any_call(
+                    'too few arguments')
+
+    def test_missing_main_option(self):
+        """Verify error is returned for a missing primary option"""
+        sys_argv = ['./command', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            with patch('argparse.ArgumentParser.error', self.error_mock):
+                lookup = StackLookup()
+                lookup.parse_arguments('')
+                self.error_mock.assert_called_with(
+                    'Must specify one of -l/--list-projects or -p/--project')
+
+    def test_missing_project_option(self):
+        """Verify error is returned for a missing project option"""
+        sys_argv = ['./command', '--project', 'foo', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            with patch('argparse.ArgumentParser.error', self.error_mock):
+                lookup = StackLookup()
+                lookup.parse_arguments('')
+                self.error_mock.assert_called_with(
+                    'Must specify -a/--autolanding, -c/--ci or '
+                    '-t/--attribute with -p/--project')
+
+    def test_missing_project_option_with_children(self):
+        """Verify error is returned for a missing project and children
+        option"""
+        sys_argv = ['./command', '--project', 'foo', '--attribute',
+                    'target_branch', '--children', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            with patch('argparse.ArgumentParser.error', self.error_mock):
+                lookup = StackLookup()
+                lookup.parse_arguments('')
+                self.error_mock.assert_called_with(
+                    'Must specify -a/--autolanding or -c/--ci with '
+                    '-i/--children')
+
+    def test_list_projects(self):
+        """Verify a list projects request"""
+        sys_argv = ['./command', '-l', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertTrue(ret.list_projects)
+
+    def test_project_ci(self):
+        """Verify a ci job request"""
+        sys_argv = ['./command', '-p', 'project', '-c', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertTrue(ret.ci)
+            self.assertEqual('project', ret.project)
+
+    def test_project_autoland(self):
+        """Verify a ci job request"""
+        sys_argv = ['./command', '-p', 'project', '-a', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertTrue(ret.autoland)
+            self.assertEqual('project', ret.project)
+
+    def test_project_ci_children(self):
+        """Verify a ci job request"""
+        sys_argv = ['./command', '-p', 'project', '-c', '-i', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertTrue(ret.ci)
+            self.assertTrue(ret.children)
+
+    def test_project_autoland_children(self):
+        """Verify a ci job request"""
+        sys_argv = ['./command', '-p', 'project', '-a', '-i', 'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertTrue(ret.autoland)
+            self.assertTrue(ret.children)
+
+    def test_project_attribute(self):
+        """Verify a ci job request"""
+        sys_argv = ['./command', '-p', 'project', '-t', 'target_branch',
+                    'stack.cfg']
+        with patch('sys.argv', sys_argv):
+            lookup = StackLookup()
+            ret = lookup.parse_arguments('')
+            self.assertEqual('project', ret.project)
+            self.assertEqual('target_branch', ret.attribute)