Merge lp:~tsimonq2/ubuntu-qa-website/python-library-merge into lp:ubuntu-qa-website

[Simon Quigley]

=== added directory 'python-library'
=== added file 'python-library/qatracker.py'
--- python-library/qatracker.py	1970-01-01 00:00:00 +0000
+++ python-library/qatracker.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,535 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011, 2012  Canonical Ltd.
+# Author: Stéphane Graber <[e-mail]>
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+# This library 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
+# Lesser General Public License for more details.
+
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+try:
+    import xmlrpc.client as xmlrpclib
+except ImportError:
+    import xmlrpclib
+
+import base64
+from datetime import datetime
+
+# Taken from qatracker/qatracker.modules (PHP code)
+# cat qatracker.module | grep " = array" | sed -e 's/^\$//g' \
+#   -e 's/array(/[/g' -e 's/);/]/g' -e "s/t('/\"/g" -e "s/')/\"/g"
+### AUTO-GENERATED ->
+qatracker_build_milestone_status = ["Active", "Re-building", "Disabled",
+                                    "Superseded", "Ready"]
+qatracker_milestone_notify = ["No", "Yes"]
+qatracker_milestone_autofill = ["No", "Yes"]
+qatracker_milestone_status = ["Testing", "Released", "Archived"]
+qatracker_milestone_series_status = ["Active", "Disabled"]
+qatracker_milestone_series_manifest_status = ["Active", "Disabled"]
+qatracker_product_status = ["Active", "Disabled"]
+qatracker_product_type = ["iso", "package", "hardware"]
+qatracker_product_download_type = ["HTTP", "RSYNC", "ZSYNC",
+                                   "GPG signature", "MD5 checksum", "Comment",
+                                   "Torrent"]
+qatracker_testsuite_testcase_status = ["Mandatory", "Disabled", "Run-once",
+                                       "Optional"]
+qatracker_result_result = ["Failed", "Passed", "In progress"]
+qatracker_result_status = ["Active", "Disabled"]
+qatracker_rebuild_status = ["Requested", "Queued", "Building", "Built",
+                            "Published", "Canceled"]
+### <- AUTO-GENERATED
+
+
+class QATrackerRPCObject():
+    """Base class for objects received over XML-RPC"""
+
+    CONVERT_BOOL = []
+    CONVERT_DATE = []
+    CONVERT_INT = []
+
+    def __init__(self, tracker, rpc_dict):
+        # Convert the dict we get from the API into an object
+
+        for key in rpc_dict:
+            if key in self.CONVERT_INT:
+                try:
+                    setattr(self, key, int(rpc_dict[key]))
+                except ValueError:
+                    setattr(self, key, None)
+            elif key in self.CONVERT_BOOL:
+                setattr(self, key, rpc_dict[key] == "true")
+            elif key in self.CONVERT_DATE:
+                try:
+                    setattr(self, key, datetime.strptime(rpc_dict[key],
+                                                         '%Y-%m-%d %H:%M:%S'))
+                except ValueError:
+                    setattr(self, key, None)
+            else:
+                setattr(self, key, str(rpc_dict[key]))
+
+        self.tracker = tracker
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.title)
+
+
+class QATrackerBug(QATrackerRPCObject):
+    """A bug entry"""
+
+    CONVERT_INT = ['bugnumber', 'count']
+    CONVERT_DATE = ['earliest_report', 'latest_report']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.bugnumber)
+
+
+class QATrackerBuild(QATrackerRPCObject):
+    """A build entry"""
+
+    CONVERT_INT = ['id', 'productid', 'userid', 'status']
+    CONVERT_DATE = ['date']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.id)
+
+    def add_result(self, testcase, result, comment='', hardware='', bugs={}):
+        """Add a result to the build"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        build_testcase = None
+
+        # FIXME: Supporting 'str' containing the testcase name would be nice
+        if isinstance(testcase, QATrackerTestcase):
+            build_testcase = testcase.id
+        elif isinstance(testcase, int):
+            build_testcase = testcase
+
+        if not build_testcase:
+            raise IndexError("Couldn't find testcase: %s" % (testcase,))
+
+        if isinstance(result, list):
+            raise TypeError("result must be a string or an integer")
+
+        build_result = self.tracker._get_valid_id_list(qatracker_result_result,
+                                                       result)
+
+        if not isinstance(bugs, dict):
+            raise TypeError("bugs must be a dict")
+
+        for bug in bugs:
+            if not isinstance(bug, int) or bug <= 0:
+                raise ValueError("A bugnumber must be a number >= 0")
+
+            if not isinstance(bugs[bug], int) or bugs[bug] not in (0, 1):
+                raise ValueError("A bugimportance must be in (0,1)")
+
+        resultid = int(self.tracker.tracker.results.add(self.id,
+                                                        build_testcase,
+                                                        build_result[0],
+                                                        str(comment),
+                                                        str(hardware),
+                                                        bugs))
+        if resultid == -1:
+            raise Exception("Couldn't post your result.")
+
+        new_result = None
+        for entry in self.get_results(build_testcase, 0):
+            if entry.id == resultid:
+                new_result = entry
+                break
+
+        return new_result
+
+    def get_results(self, testcase, status=qatracker_result_status):
+        """Get a list of results for the given build and testcase"""
+
+        build_testcase = None
+
+        # FIXME: Supporting 'str' containing the testcase name would be nice
+        if isinstance(testcase, QATrackerTestcase):
+            build_testcase = testcase.id
+        elif isinstance(testcase, int):
+            build_testcase = testcase
+
+        if not build_testcase:
+            raise IndexError("Couldn't find testcase: %s" % (testcase,))
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_result_status,
+            status)
+
+        if len(record_filter) == 0:
+            return []
+
+        results = []
+        for entry in self.tracker.tracker.results.get_list(
+                self.id, build_testcase, list(record_filter)):
+            results.append(QATrackerResult(self.tracker, entry))
+
+        return results
+
+
+class QATrackerMilestone(QATrackerRPCObject):
+    """A milestone entry"""
+
+    CONVERT_INT = ['id', 'status', 'series']
+    CONVERT_BOOL = ['notify']
+
+    def get_bugs(self):
+        """Returns a list of all bugs linked to this milestone"""
+
+        bugs = []
+        for entry in self.tracker.tracker.bugs.get_list(self.id):
+            bugs.append(QATrackerBug(self.tracker, entry))
+
+        return bugs
+
+    def add_build(self, product, version, note="", notify=True):
+        """Add a build to the milestone"""
+
+        if self.status != 0:
+            raise TypeError("Only active milestones are accepted")
+
+        if self.tracker.access != "admin" and self.tracker.access is not None:
+            raise Exception("Access denied, you need 'admin' but are '%s'" %
+                            self.tracker.access)
+
+        if not isinstance(notify, bool):
+            raise TypeError("notify must be a boolean")
+
+        build_product = None
+
+        if isinstance(product, QATrackerProduct):
+            build_product = product
+        else:
+            valid_products = self.tracker.get_products(0)
+
+            for entry in valid_products:
+                if (entry.title.lower() == str(product).lower() or
+                        entry.id == product):
+                    build_product = entry
+                    break
+
+        if not build_product:
+            raise IndexError("Couldn't find product: %s" % product)
+
+        if build_product.status != 0:
+            raise TypeError("Only active products are accepted")
+
+        self.tracker.tracker.builds.add(build_product.id, self.id,
+                                        str(version), str(note), notify)
+
+        new_build = None
+        for entry in self.get_builds(0):
+            if (entry.productid == build_product.id
+                    and entry.version == str(version)):
+                new_build = entry
+                break
+
+        return new_build
+
+    def get_builds(self, status=qatracker_build_milestone_status):
+        """Get a list of builds for the milestone"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_build_milestone_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        builds = []
+        for entry in self.tracker.tracker.builds.get_list(self.id,
+                                                          list(record_filter)):
+            builds.append(QATrackerBuild(self.tracker, entry))
+
+        return builds
+
+
+class QATrackerProduct(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'type', 'status']
+
+    def get_testcases(self, series,
+                      status=qatracker_testsuite_testcase_status):
+        """Get a list of testcases associated with the product"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_testsuite_testcase_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        if isinstance(series, QATrackerMilestone):
+            seriesid = series.series
+        elif isinstance(series, int):
+            seriesid = series
+        else:
+            raise TypeError("series needs to be a valid QATrackerMilestone"
+                            " instance or an integer")
+
+        testcases = []
+        for entry in self.tracker.tracker.testcases.get_list(
+                self.id, seriesid, list(record_filter)):
+            testcases.append(QATrackerTestcase(self.tracker, entry))
+
+        return testcases
+
+
+class QATrackerRebuild(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'seriesid', 'productid', 'milestoneid', 'requestedby',
+                   'changedby', 'status']
+    CONVERT_DATE = ['requestedat', 'changedat']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.id)
+
+    def save(self):
+        """Save any change that happened on this entry.
+           NOTE: At the moment only supports the status field."""
+
+        if (self.tracker.access != "admin" and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'admin' but are '%s'" %
+                            self.tracker.access)
+
+        retval = self.tracker.tracker.rebuilds.update_status(self.id,
+                                                             self.status)
+        if retval is not True:
+            raise Exception("Failed to update rebuild")
+
+        return retval
+
+
+class QATrackerResult(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'reporterid', 'revisionid', 'result', 'changedby',
+                   'status']
+    CONVERT_DATE = ['date', 'lastchange']
+    __deleted = False
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.id)
+
+    def delete(self):
+        """Remove the result from the tracker"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        if self.__deleted:
+            raise IndexError("Result has already been removed")
+
+        retval = self.tracker.tracker.results.delete(self.id)
+        if retval is not True:
+            raise Exception("Failed to remove result")
+
+        self.status = 1
+        self.__deleted = True
+
+    def save(self):
+        """Save any change that happened on this entry"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        if self.__deleted:
+            raise IndexError("Result no longer exists")
+
+        retval = self.tracker.tracker.results.update(self.id, self.result,
+                                                     self.comment,
+                                                     self.hardware,
+                                                     self.bugs)
+        if retval is not True:
+            raise Exception("Failed to update result")
+
+        return retval
+
+
+class QATrackerSeries(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'status']
+
+    def get_manifest(self, status=qatracker_milestone_series_manifest_status):
+        """Get a list of products in the series' manifest"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_milestone_series_manifest_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        manifest_entries = []
+        for entry in self.tracker.tracker.series.get_manifest(
+                self.id, list(record_filter)):
+            manifest_entries.append(QATrackerSeriesManifest(
+                                    self.tracker, entry))
+
+        return manifest_entries
+
+
+class QATrackerSeriesManifest(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'productid', 'status']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.product_title)
+
+
+class QATrackerTestcase(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'status', 'weight', 'suite']
+
+
+class QATracker():
+    def __init__(self, url, username=None, password=None):
+        class AuthTransport(xmlrpclib.Transport):
+            def set_auth(self, auth):
+                self.auth = auth
+
+            def get_host_info(self, host):
+                host, extra_headers, x509 = \
+                    xmlrpclib.Transport.get_host_info(self, host)
+                if extra_headers is None:
+                    extra_headers = []
+                extra_headers.append(('Authorization', 'Basic %s' % auth))
+                return host, extra_headers, x509
+
+        if username and password:
+            try:
+                auth = str(base64.b64encode(
+                           bytes('%s:%s' % (username, password), 'utf-8')),
+                           'utf-8')
+            except TypeError:
+                auth = base64.b64encode('%s:%s' % (username, password))
+
+            transport = AuthTransport()
+            transport.set_auth(auth)
+            drupal = xmlrpclib.ServerProxy(url, transport=transport)
+        else:
+            drupal = xmlrpclib.ServerProxy(url)
+
+        # Call listMethods() so if something is wrong we know it immediately
+        drupal.system.listMethods()
+
+        # Get our current access
+        self.access = drupal.qatracker.get_access()
+
+        self.tracker = drupal.qatracker
+
+    def _get_valid_id_list(self, status_list, status):
+        """ Get a list of valid keys and a list or just a single
+            entry of input to check against the list of valid keys.
+            The function looks for valid indexes and content, doing
+            case insensitive checking for strings and returns a list
+            of indexes for the list of valid keys. """
+
+        def process(status_list, status):
+            valid_status = [entry.lower() for entry in status_list]
+
+            if isinstance(status, int):
+                if status < 0 or status >= len(valid_status):
+                    raise IndexError("Invalid status: %s" % status)
+                return int(status)
+
+            if isinstance(status, str):
+                status = status.lower()
+                if status not in valid_status:
+                    raise IndexError("Invalid status: %s" % status)
+                return valid_status.index(status)
+
+            raise TypeError("Invalid status type: %s (expected str or int)" %
+                            type(status))
+
+        record_filter = set()
+
+        if isinstance(status, list):
+            for entry in status:
+                record_filter.add(process(status_list, entry))
+        else:
+            record_filter.add(process(status_list, status))
+
+        return list(record_filter)
+
+    def get_bugs(self):
+        """Get a list of all bugs reported on the site"""
+
+        bugs = []
+        for entry in self.tracker.bugs.get_list(0):
+            bugs.append(QATrackerBug(self, entry))
+
+        return bugs
+
+    def get_milestones(self, status=qatracker_milestone_status):
+        """Get a list of all milestones"""
+
+        record_filter = self._get_valid_id_list(qatracker_milestone_status,
+                                                status)
+
+        if len(record_filter) == 0:
+            return []
+
+        milestones = []
+        for entry in self.tracker.milestones.get_list(list(record_filter)):
+            milestones.append(QATrackerMilestone(self, entry))
+
+        return milestones
+
+    def get_products(self, status=qatracker_product_status):
+        """Get a list of all products"""
+
+        record_filter = self._get_valid_id_list(qatracker_product_status,
+                                                status)
+
+        if len(record_filter) == 0:
+            return []
+
+        products = []
+        for entry in self.tracker.products.get_list(list(record_filter)):
+            products.append(QATrackerProduct(self, entry))
+
+        return products
+
+    def get_rebuilds(self, status=qatracker_rebuild_status):
+        """Get a list of all rebuilds"""
+
+        record_filter = self._get_valid_id_list(
+            qatracker_rebuild_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        rebuilds = []
+        for entry in self.tracker.rebuilds.get_list(list(record_filter)):
+            rebuilds.append(QATrackerRebuild(self, entry))
+
+        return rebuilds
+
+    def get_series(self, status=qatracker_milestone_series_status):
+        """Get a list of all series"""
+
+        record_filter = self._get_valid_id_list(
+            qatracker_milestone_series_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        series = []
+        for entry in self.tracker.series.get_list(list(record_filter)):
+            series.append(QATrackerSeries(self, entry))
+
+        return series

=== added directory 'python-library/tests'
=== added file 'python-library/tests/run'
--- python-library/tests/run	1970-01-01 00:00:00 +0000
+++ python-library/tests/run	2016-03-01 21:32:25 +0000
@@ -0,0 +1,35 @@
+#!/usr/bin/python3
+import unittest
+import os
+import re
+import shutil
+import sys
+
+coverage = True
+try:
+    from coverage import coverage
+    cov = coverage()
+    cov.start()
+except ImportError:
+    print("No coverage report, make sure python-coverage is installed")
+    coverage = False
+
+sys.path.insert(0, '.')
+
+if len(sys.argv) > 1:
+    test_filter = sys.argv[1]
+else:
+    test_filter = ''
+
+tests = [t[:-3] for t in os.listdir('tests')
+         if t.startswith('test_') and t.endswith('.py') and
+         re.search(test_filter, t)]
+tests.sort()
+suite = unittest.TestLoader().loadTestsFromNames(tests)
+res = unittest.TextTestRunner(verbosity=2).run(suite)
+
+if coverage:
+    if os.path.exists('tests/coverage'):
+        shutil.rmtree('tests/coverage')
+    cov.stop()
+    cov.html_report(include=["qatracker.py"], directory='tests/coverage')

=== added file 'python-library/tests/setup.sql'
--- python-library/tests/setup.sql	1970-01-01 00:00:00 +0000
+++ python-library/tests/setup.sql	2016-03-01 21:32:25 +0000
@@ -0,0 +1,4 @@
+INSERT INTO users (uid, name, data, status) VALUES (99999, 'user', 'a:1:{s:17:"qatracker_api_key";s:4:"user";}', 1);
+INSERT INTO users (uid, name, data, status) VALUES (99998, 'admin', 'a:1:{s:17:"qatracker_api_key";s:5:"admin";}', 1);
+INSERT INTO users_roles (uid, rid) VALUES (99999, 2);
+INSERT INTO users_roles (uid, rid) VALUES (99998, 4);

=== added file 'python-library/tests/test_bug.py'
--- python-library/tests/test_bug.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_bug.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,17 @@
+import unittest
+import qatracker
+import datetime
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class BugTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL)
+
+    def test_all_bugs(self):
+        bugs = self.instance.get_bugs()
+        if bugs:
+            self.assertIsInstance(bugs[0].bugnumber, int)
+            self.assertIsInstance(bugs[0].earliest_report, datetime.datetime)
+            self.assertTrue(str(bugs[0]).startswith('QATrackerBug: '))

=== added file 'python-library/tests/test_build.py'
--- python-library/tests/test_build.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_build.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,98 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class BuildTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL, 'admin', 'admin')
+        self.milestone = self.instance.get_milestones('testing')[0]
+
+    def test_build_lower(self):
+        self.assertIsInstance(self.milestone.get_builds('active'), list)
+
+    def test_build_mixed(self):
+        self.assertIsInstance(self.milestone.get_builds('DisAblEd'), list)
+
+    def test_build_upper(self):
+        self.assertIsInstance(self.milestone.get_builds('RE-BUILDING'), list)
+
+    def test_build_id(self):
+        self.assertIsInstance(self.milestone.get_builds(3), list)
+
+    def test_build_list(self):
+        self.assertIsInstance(self.milestone.get_builds(['Re-Building', 0,
+                                                         'DISABLED',
+                                                         'SuperSeded']), list)
+
+    def test_build_empty_list(self):
+        self.assertEquals(self.milestone.get_builds([]), [])
+
+    def test_build_all(self):
+        self.assertIsInstance(self.milestone.get_builds(), list)
+
+    def test_build_type(self):
+        build = self.milestone.get_builds(0)[0]
+        self.assertIsInstance(build, qatracker.QATrackerBuild)
+        self.assertIsInstance(build.status, int)
+        self.assertIsInstance(build.version, str)
+
+    def test_build_repr(self):
+        build = self.milestone.get_builds(0)[0]
+        self.assertTrue(str(build).startswith('QATrackerBuild: '))
+
+    def test_build_add_by_name(self):
+        product = self.instance.get_products(0)[0]
+        self.milestone.add_build(product.title, '1234', '', False)
+
+    def test_build_add_by_id(self):
+        product = self.instance.get_products(0)[0]
+        build = self.milestone.add_build(product.id, '1234', '', False)
+        self.assertEquals(build.productid, product.id)
+        self.assertEquals(build.version, '1234')
+        self.assertEquals(build.note, '')
+
+    def test_build_invalid_add_disabled_product_by_id(self):
+        product = self.instance.get_products(1)[0]
+        self.assertRaises(IndexError, self.milestone.add_build,
+                          product=product.id, version='1234')
+
+    def test_build_invalid_add_disabled_product_by_object(self):
+        product = self.instance.get_products(1)[0]
+        self.assertRaises(TypeError, self.milestone.add_build,
+                          product=product, version='1234')
+
+    def test_build_invalid_add_disabled_milestone_by_object(self):
+        milestone = self.instance.get_milestones('archived')[0]
+        product = self.instance.get_products(1)[0]
+        self.assertRaises(TypeError, milestone.add_build,
+                          product=product, version='1234')
+
+    def test_build_invalid_add_invalid_by_name(self):
+        self.assertRaises(IndexError, self.milestone.add_build,
+                          product='bmaifno', version='1234')
+
+    def test_build_invalid_add_invalid_by_id(self):
+        self.assertRaises(IndexError, self.milestone.add_build,
+                          product=-1, version='1234')
+
+    def test_build_invalid_add_invalid_notify(self):
+        product = self.instance.get_products(0)[0]
+        self.assertRaises(TypeError, self.milestone.add_build,
+                          product=product.id, version='1234', notify=object())
+
+    def test_build_invalid_add_invalid_no_access(self):
+        instance = qatracker.QATracker(URL, 'user', 'user')
+        milestone = instance.get_milestones('testing')[0]
+        self.assertRaises(Exception, milestone.add_build, product=0,
+                          version='1234')
+
+    def test_build_invalid_id(self):
+        self.assertRaises(IndexError, self.milestone.get_builds, (-1))
+
+    def test_build_invalid_string(self):
+        self.assertRaises(IndexError, self.milestone.get_builds, ('bla'))
+
+    def test_build_invalid_type(self):
+        self.assertRaises(TypeError, self.milestone.get_builds, (object()))

=== added file 'python-library/tests/test_milestone.py'
--- python-library/tests/test_milestone.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_milestone.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,56 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class MilestoneTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL)
+
+    def test_milestone_lower(self):
+        milestones = self.instance.get_milestones('testing')
+        self.assertIsInstance(milestones, list)
+
+    def test_milestone_mixed(self):
+        milestones = self.instance.get_milestones('RelEaSed')
+        self.assertIsInstance(milestones, list)
+
+    def test_milestone_upper(self):
+        milestones = self.instance.get_milestones('ARCHIVED')
+        self.assertIsInstance(milestones, list)
+
+    def test_milestone_id(self):
+        milestones = self.instance.get_milestones(2)
+        self.assertIsInstance(milestones, list)
+
+    def test_milestone_list(self):
+        milestones = self.instance.get_milestones(['testing', 2, 'archIved'])
+        self.assertIsInstance(milestones, list)
+
+    def test_milestone_empty_list(self):
+        self.assertEquals(self.instance.get_milestones([]), [])
+
+    def test_milestone_all(self):
+        self.assertIsInstance(self.instance.get_milestones(), list)
+
+    def test_milestone_type(self):
+        milestone = self.instance.get_milestones(2)[10]
+        self.assertIsInstance(milestone, qatracker.QATrackerMilestone)
+        self.assertIsInstance(milestone.notify, bool)
+        self.assertIsInstance(milestone.status, int)
+        self.assertIsInstance(milestone.title, str)
+        self.assertIsInstance(milestone.get_bugs(), list)
+
+    def test_milestone_repr(self):
+        milestone = self.instance.get_milestones(2)[0]
+        self.assertTrue(str(milestone).startswith('QATrackerMilestone: '))
+
+    def test_milestone_invalid_id(self):
+        self.assertRaises(IndexError, self.instance.get_milestones, (-1))
+
+    def test_milestone_invalid_string(self):
+        self.assertRaises(IndexError, self.instance.get_milestones, ('bla'))
+
+    def test_milestone_invalid_type(self):
+        self.assertRaises(TypeError, self.instance.get_milestones, (object()))

=== added file 'python-library/tests/test_product.py'
--- python-library/tests/test_product.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_product.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,51 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class ProductTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL)
+
+    def test_product_lower(self):
+        self.assertIsInstance(self.instance.get_products('active'), list)
+
+    def test_product_mixed(self):
+        self.assertIsInstance(self.instance.get_products('DisAblEd'), list)
+
+    def test_product_upper(self):
+        self.assertIsInstance(self.instance.get_products('ACTIVE'), list)
+
+    def test_product_id(self):
+        self.assertIsInstance(self.instance.get_products(1), list)
+
+    def test_product_list(self):
+        self.assertIsInstance(self.instance.get_products(['ActivE', 1,
+                                                          'DISABLED',
+                                                          'disabled']), list)
+
+    def test_product_empty_list(self):
+        self.assertEquals(self.instance.get_products([]), [])
+
+    def test_product_all(self):
+        self.assertIsInstance(self.instance.get_products(), list)
+
+    def test_product_type(self):
+        product = self.instance.get_products(0)[0]
+        self.assertIsInstance(product, qatracker.QATrackerProduct)
+        self.assertIsInstance(product.status, int)
+        self.assertIsInstance(product.title, str)
+
+    def test_product_repr(self):
+        product = self.instance.get_products(0)[0]
+        self.assertTrue(str(product).startswith('QATrackerProduct: '))
+
+    def test_product_invalid_id(self):
+        self.assertRaises(IndexError, self.instance.get_products, (-1))
+
+    def test_product_invalid_string(self):
+        self.assertRaises(IndexError, self.instance.get_products, ('bla'))
+
+    def test_product_invalid_type(self):
+        self.assertRaises(TypeError, self.instance.get_products, (object()))

=== added file 'python-library/tests/test_rebuilds.py'
--- python-library/tests/test_rebuilds.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_rebuilds.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,69 @@
+import unittest
+import qatracker
+from datetime import datetime
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class ProductTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL, 'admin', 'admin')
+
+    def test_rebuilds_lower(self):
+        self.assertIsInstance(self.instance.get_rebuilds('requested'), list)
+
+    def test_rebuilds_mixed(self):
+        self.assertIsInstance(self.instance.get_rebuilds('BuIlDing'), list)
+
+    def test_rebuilds_upper(self):
+        self.assertIsInstance(self.instance.get_rebuilds('PUBLISHED'), list)
+
+    def test_rebuilds_id(self):
+        self.assertIsInstance(self.instance.get_rebuilds(3), list)
+
+    def test_rebuilds_list(self):
+        self.assertIsInstance(self.instance.get_rebuilds(['reQuested', 1,
+                                                        'PUBLISHED',
+                                                        'canceled']), list)
+
+    def test_rebuilds_empty_list(self):
+        self.assertEquals(self.instance.get_rebuilds([]), [])
+
+    def test_rebuilds_all(self):
+        self.assertIsInstance(self.instance.get_rebuilds(), list)
+
+    def test_rebuilds_type(self):
+        rebuild = self.instance.get_rebuilds()[0]
+        self.assertIsInstance(rebuild, qatracker.QATrackerRebuild)
+        self.assertIsInstance(rebuild.id, int)
+        self.assertIsInstance(rebuild.product_title, str)
+        self.assertIsInstance(rebuild.requestedat, datetime)
+
+    def test_rebuilds_repr(self):
+        rebuild = self.instance.get_rebuilds()[0]
+        self.assertTrue(str(rebuild).startswith('QATrackerRebuild: '))
+
+    def test_rebuilds_invalid_id(self):
+        self.assertRaises(IndexError, self.instance.get_rebuilds, -1)
+
+    def test_rebuilds_invalid_string(self):
+        self.assertRaises(IndexError, self.instance.get_rebuilds, 'bla')
+
+    def test_rebuilds_invalid_type(self):
+        self.assertRaises(TypeError, self.instance.get_rebuilds, object())
+
+    def test_rebuilds_invalid_save_no_access(self):
+        instance = qatracker.QATracker(URL)
+        rebuild = instance.get_rebuilds()[0]
+        rebuild.status = 2
+        self.assertRaises(Exception, rebuild.save)
+
+    def test_rebuilds_valid_save(self):
+        rebuild = self.instance.get_rebuilds()[0]
+        rebuild.status = 2
+        self.assertTrue(rebuild.save())
+
+    def test_rebuilds_invalid_status_save(self):
+        rebuild = self.instance.get_rebuilds()[0]
+        rebuild.status = 99
+        self.assertRaises(Exception, rebuild.save)

=== added file 'python-library/tests/test_result.py'
--- python-library/tests/test_result.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_result.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,173 @@
+import unittest
+import qatracker
+import datetime
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class ResultTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL, 'user', 'user')
+        self.milestone = self.instance.get_milestones('testing')[0]
+        self.builds = self.milestone.get_builds('active')
+
+    def test_result_by_object(self):
+        results = []
+        for product in self.instance.get_products('active'):
+            builds = [build for build in self.builds
+                      if build.productid == product.id]
+            if len(builds) == 0:
+                continue
+
+            for testcase in product.get_testcases(self.milestone, 'mandatory'):
+                build = builds[0]
+                results += build.get_results(testcase)
+                if len(results) > 0:
+                    break
+            else:
+                continue
+            break
+
+        result = results[0]
+        self.assertIsInstance(result, qatracker.QATrackerResult)
+        self.assertIsInstance(result.id, int)
+        self.assertIsInstance(result.date, datetime.datetime)
+        self.assertIsInstance(result.comment, str)
+        self.assertTrue(str(result).startswith('QATrackerResult: '))
+
+    def test_result_by_id(self):
+        results = []
+        for product in self.instance.get_products('active'):
+            builds = [build for build in self.builds
+                      if build.productid == product.id]
+            if len(builds) == 0:
+                continue
+
+            for testcase in product.get_testcases(self.milestone, 'mandatory'):
+                build = builds[0]
+                results += build.get_results(testcase.id)
+                if len(results) > 0:
+                    break
+            else:
+                continue
+            break
+
+        result = results[0]
+        self.assertIsInstance(result, qatracker.QATrackerResult)
+        self.assertIsInstance(result.id, int)
+        self.assertIsInstance(result.date, datetime.datetime)
+        self.assertIsInstance(result.comment, str)
+        self.assertTrue(str(result).startswith('QATrackerResult: '))
+
+    def test_result_add_by_object(self):
+        testcase = None
+        build = None
+
+        for product in self.instance.get_products('active'):
+            builds = [build for build in self.builds
+                      if build.productid == product.id]
+            if len(builds) == 0:
+                continue
+
+            build = builds[0]
+            testcase = product.get_testcases(self.milestone, 'mandatory')[0]
+            break
+
+        result = build.add_result(testcase, 'failed')
+        self.assertIsInstance(result, qatracker.QATrackerResult)
+        self.assertIsInstance(result.id, int)
+        self.assertIsInstance(result.date, datetime.datetime)
+        self.assertIsInstance(result.comment, str)
+        self.assertEquals(result.result, 0)
+        self.assertTrue(str(result).startswith('QATrackerResult: '))
+
+        result.comment = "edited"
+        result.save()
+        result.delete()
+
+        self.assertRaises(Exception, result.save)
+
+    def test_result_add_by_id(self):
+        testcase = None
+        build = None
+
+        for product in self.instance.get_products('active'):
+            builds = [build for build in self.builds
+                      if build.productid == product.id]
+            if len(builds) == 0:
+                continue
+
+            build = builds[0]
+            testcase = product.get_testcases(self.milestone, 'mandatory')[0]
+            break
+
+        result = build.add_result(testcase.id, 2)
+        self.assertIsInstance(result, qatracker.QATrackerResult)
+        self.assertIsInstance(result.id, int)
+        self.assertIsInstance(result.date, datetime.datetime)
+        self.assertIsInstance(result.comment, str)
+        self.assertEquals(result.result, 2)
+        self.assertTrue(str(result).startswith('QATrackerResult: '))
+
+        result.delete()
+
+        self.assertRaises(Exception, result.delete)
+
+    def test_result_invalid_remove(self):
+        result = qatracker.QATrackerResult(self.instance, {'id': '0'})
+        self.assertRaises(Exception, result.delete)
+
+    def test_result_invalid_remove_no_access(self):
+        instance = qatracker.QATracker(URL)
+        result = qatracker.QATrackerResult(instance, {'id': '0'})
+        self.assertRaises(Exception, result.delete)
+
+    def test_result_invalid_save(self):
+        result = qatracker.QATrackerResult(self.instance, {'id': '0',
+                                                           'comment': '',
+                                                           'result': '0',
+                                                           'hardware': '',
+                                                           'bugs': {}})
+        self.assertRaises(Exception, result.save)
+
+    def test_result_invalid_save_no_access(self):
+        instance = qatracker.QATracker(URL)
+        result = qatracker.QATrackerResult(instance, {'id': '0'})
+        self.assertRaises(Exception, result.save)
+
+    def test_result_invalid_add_invalid_testcase(self):
+        self.assertRaises(IndexError, self.builds[0].add_result,
+                          testcase=object(), result='in progress')
+
+    def test_result_invalid_add_invalid_result(self):
+        self.assertRaises(TypeError, self.builds[0].add_result,
+                          testcase=1, result=['in progress'])
+
+    def test_result_invalid_add_invalid_bugs(self):
+        self.assertRaises(TypeError, self.builds[0].add_result,
+                          testcase=1, result='in progress', bugs="bla")
+
+    def test_result_invalid_add_invalid_bugnumber(self):
+        self.assertRaises(ValueError, self.builds[0].add_result,
+                          testcase=1, result='in progress', bugs={-1: 0})
+
+    def test_result_invalid_add_invalid_bugimportance(self):
+        self.assertRaises(ValueError, self.builds[0].add_result,
+                          testcase=1, result='in progress', bugs={123: 'a'})
+
+    def test_result_invalid_add_invalid_response(self):
+        self.assertRaises(Exception, self.builds[0].add_result,
+                          testcase=-1, result='in progress')
+
+    def test_result_invalid_add_invalid_no_access(self):
+        instance = qatracker.QATracker(URL)
+        milestone = instance.get_milestones('testing')[0]
+        builds = milestone.get_builds('active')
+        self.assertRaises(Exception, builds[0].add_result,
+                          testcase=10, result='in progress')
+
+    def test_result_invalid_id(self):
+        self.assertRaises(IndexError, self.builds[0].get_results, (object()))
+
+    def test_result_invalid_no_status(self):
+        self.assertEquals(self.builds[0].get_results(1234, []), [])

=== added file 'python-library/tests/test_rpc.py'
--- python-library/tests/test_rpc.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_rpc.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,27 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+try:
+    import xmlrpc.client as xmlrpclib
+except ImportError:
+    import xmlrpclib
+
+
+class RPCTests(unittest.TestCase):
+    def test_rpc_anonymous(self):
+        tracker = qatracker.QATracker(URL)
+        self.assertEquals(tracker.access, 'public')
+
+    def test_rpc_authenticated_user(self):
+        tracker = qatracker.QATracker(URL, 'user', 'user')
+        self.assertEquals(tracker.access, 'user')
+
+    def test_rpc_authenticated_admin(self):
+        tracker = qatracker.QATracker(URL, 'admin', 'admin')
+        self.assertEquals(tracker.access, 'admin')
+
+    def test_rpc_invalid_target(self):
+        self.assertRaises(xmlrpclib.ProtocolError, qatracker.QATracker,
+                          ("%s.invalid" % URL))

=== added file 'python-library/tests/test_series.py'
--- python-library/tests/test_series.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_series.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,77 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class ProductTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL)
+
+    def test_series_lower(self):
+        self.assertIsInstance(self.instance.get_series('active'), list)
+
+    def test_series_mixed(self):
+        self.assertIsInstance(self.instance.get_series('DisAblEd'), list)
+
+    def test_series_upper(self):
+        self.assertIsInstance(self.instance.get_series('ACTIVE'), list)
+
+    def test_series_id(self):
+        self.assertIsInstance(self.instance.get_series(1), list)
+
+    def test_series_list(self):
+        self.assertIsInstance(self.instance.get_series(['AcTiVe', 1,
+                                                        'DISABLED',
+                                                        'active']), list)
+
+    def test_series_empty_list(self):
+        self.assertEquals(self.instance.get_series([]), [])
+
+    def test_series_all(self):
+        self.assertIsInstance(self.instance.get_series(), list)
+
+    def test_series_type(self):
+        series = self.instance.get_series()[0]
+        self.assertIsInstance(series, qatracker.QATrackerSeries)
+        self.assertIsInstance(series.id, int)
+        self.assertIsInstance(series.title, str)
+
+    def test_series_repr(self):
+        series = self.instance.get_series()[0]
+        self.assertTrue(str(series).startswith('QATrackerSeries: '))
+
+    def test_series_invalid_id(self):
+        self.assertRaises(IndexError, self.instance.get_series, -1)
+
+    def test_series_invalid_string(self):
+        self.assertRaises(IndexError, self.instance.get_series, 'bla')
+
+    def test_series_invalid_type(self):
+        self.assertRaises(TypeError, self.instance.get_series, object())
+
+    def test_series_manifest_all(self):
+        self.assertIsInstance(self.instance.get_series()[0].get_manifest(),
+                              list)
+
+    def test_series_manifest_none(self):
+        self.assertIsInstance(self.instance.get_series()[0].get_manifest([]),
+                              list)
+
+    def test_series_manifest_type(self):
+        for series in self.instance.get_series():
+            manifest = series.get_manifest()
+            if manifest:
+                self.assertIsInstance(manifest[0],
+                                      qatracker.QATrackerSeriesManifest)
+                self.assertIsInstance(manifest[0].productid, int)
+                self.assertIsInstance(manifest[0].product_title, str)
+                break
+
+    def test_series_manifest_repr(self):
+        for series in self.instance.get_series():
+            manifest = series.get_manifest()
+            if manifest:
+                self.assertTrue(str(manifest[0]).startswith(
+                                'QATrackerSeriesManifest: '))
+                break

=== added file 'python-library/tests/test_testcase.py'
--- python-library/tests/test_testcase.py	1970-01-01 00:00:00 +0000
+++ python-library/tests/test_testcase.py	2016-03-01 21:32:25 +0000
@@ -0,0 +1,68 @@
+import unittest
+import qatracker
+
+URL = 'http://iso.qa.dev.stgraber.org/xmlrpc.php'
+
+
+class TestcaseTests(unittest.TestCase):
+    def setUp(self):
+        self.instance = qatracker.QATracker(URL)
+        self.product = self.instance.get_products(0)[0]
+        self.milestone = self.instance.get_milestones()[0]
+
+    def test_testcase_lower(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone,
+                                                         'mandatory'), list)
+
+    def test_testcase_mixed(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone,
+                                                         'DisAblEd'), list)
+
+    def test_testcase_upper(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone,
+                                                         'RUN-ONCE'), list)
+
+    def test_testcase_id(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone,
+                                                         3), list)
+
+    def test_testcase_seriesid(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone.series,
+                                                         3), list)
+
+    def test_testcase_list(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone,
+                                                         ['Run-once', 0,
+                                                          'DISABLED',
+                                                          'optional']), list)
+
+    def test_testcase_empty_list(self):
+        self.assertEquals(self.product.get_testcases(self.milestone, []), [])
+
+    def test_testcase_all(self):
+        self.assertIsInstance(self.product.get_testcases(self.milestone), list)
+
+    def test_testcase_type(self):
+        testcase = self.product.get_testcases(self.milestone, 0)[0]
+        self.assertIsInstance(testcase, qatracker.QATrackerTestcase)
+        self.assertIsInstance(testcase.status, int)
+        self.assertIsInstance(testcase.title, str)
+
+    def test_testcase_repr(self):
+        testcase = self.product.get_testcases(self.milestone, 0)[0]
+        self.assertTrue(str(testcase).startswith('QATrackerTestcase: '))
+
+    def test_testcase_invalid_id(self):
+        self.assertRaises(IndexError, self.product.get_testcases,
+                          self.milestone, -1)
+
+    def test_testcase_invalid_string(self):
+        self.assertRaises(IndexError, self.product.get_testcases,
+                          self.milestone, 'bla')
+
+    def test_testcase_invalid_type(self):
+        self.assertRaises(TypeError, self.product.get_testcases,
+                          self.milestone, object())
+
+    def test_testcase_invalid_seriesid(self):
+        self.assertRaises(TypeError, self.product.get_testcases, object(), 3)