Separate tests in separate files and classes

Split existing tests into separate files and classes to make it easier
to select a subset to be executed when making modifications.

Add some simple consolidations of test data as example improvements that
can be extended by consolidating complete tests or sets of tests.

Change-Id: If2380e6f4e848ba68f05868e2ef4186d7912952b

tests/base.py

@@ -0,0 +1,42 @@
+import sys
+
+from six.moves.urllib.request import build_opener
+
+import jenkins
+
+if sys.version_info < (2, 7):
+    import unittest2 as unittest
+else:
+    import unittest
+
+
+class JenkinsTestBase(unittest.TestCase):
+
+    crumb_data = {
+        "crumb": "dab177f483b3dd93483ef6716d8e792d",
+        "crumbRequestField": ".crumb",
+    }
+
+    def setUp(self):
+        super(JenkinsTestBase, self).setUp()
+        self.opener = build_opener()
+
+        self.j = jenkins.Jenkins('http://example.com/', 'test', 'test')
+
+    def _check_requests(self, requests):
+
+        for req in requests:
+            self._check_request(req[0][0])
+
+    def _check_request(self, request):
+
+        # taken from opener.open() in request
+        # attribute request.type is only set automatically for python 3
+        # requests, must use request.get_type() for python 2.7
+        protocol = request.type or request.get_type()
+
+        # check that building the request doesn't throw any exception
+        meth_name = protocol + "_request"
+        for processor in self.opener.process_request.get(protocol, []):
+            meth = getattr(processor, meth_name)
+            request = meth(request)

tests/jobs/base.py

@@ -0,0 +1,10 @@
+from tests.base import JenkinsTestBase
+
+
+class JenkinsJobsTestBase(JenkinsTestBase):
+
+    config_xml = """
+        <matrix-project>
+            <actions/>
+            <description>Foo</description>
+        </matrix-project>"""

tests/jobs/test_assert.py

@@ -0,0 +1,27 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsAssertJobExistsTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_job_missing(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.NotFoundException()
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.assert_job_exists('NonExistent')
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[NonExistent] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_job_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'ExistingJob'}),
+        ]
+        self.j.assert_job_exists('ExistingJob')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_build.py

@@ -0,0 +1,50 @@
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsBuildJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            {'foo': 'bar'},
+        ]
+
+        build_info = self.j.build_job(u'Test Job')
+
+        self.assertEqual(jenkins_mock.call_args[0][0].get_full_url(),
+                         u'http://example.com/job/Test%20Job/build')
+        self.assertEqual(build_info, {'foo': 'bar'})
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_with_token(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            {'foo': 'bar'},
+        ]
+
+        build_info = self.j.build_job(u'TestJob', token='some_token')
+
+        self.assertEqual(jenkins_mock.call_args[0][0].get_full_url(),
+                         u'http://example.com/job/TestJob/build?token=some_token')
+        self.assertEqual(build_info, {'foo': 'bar'})
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_with_parameters_and_token(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            {'foo': 'bar'},
+        ]
+
+        build_info = self.j.build_job(
+            u'TestJob',
+            parameters={'when': 'now', 'why': 'because I felt like it'},
+            token='some_token')
+
+        self.assertTrue('token=some_token' in jenkins_mock.call_args[0][0].get_full_url())
+        self.assertTrue('when=now' in jenkins_mock.call_args[0][0].get_full_url())
+        self.assertTrue('why=because+I+felt+like+it' in jenkins_mock.call_args[0][0].get_full_url())
+        self.assertEqual(build_info, {'foo': 'bar'})
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_config.py

@@ -0,0 +1,16 @@
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsGetJobConfigTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_encodes_job_name(self, jenkins_mock):
+        self.j.get_job_config(u'Test Job')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/config.xml')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_copy.py

@@ -0,0 +1,43 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsCopyJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'Test Job_2'}),
+            json.dumps({'name': 'Test Job_2'}),
+            json.dumps({'name': 'Test Job_2'}),
+        ]
+
+        self.j.copy_job(u'Test Job', u'Test Job_2')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/createItem'
+            '?name=Test%20Job_2&mode=copy&from=Test%20Job')
+        self.assertTrue(self.j.job_exists('Test Job_2'))
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.copy_job(u'TestJob', u'TestJob_2')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/createItem'
+            '?name=TestJob_2&mode=copy&from=TestJob')
+        self.assertEqual(
+            str(context_manager.exception),
+            'create[TestJob_2] failed')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_count.py

@@ -0,0 +1,20 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsJobsCountTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jobs = [
+            {u'url': u'http://localhost:8080/job/guava/', u'color': u'notbuilt', u'name': u'guava'},
+            {u'url': u'http://localhost:8080/job/kiwi/', u'color': u'blue', u'name': u'kiwi'},
+            {u'url': u'http://localhost:8080/job/lemon/', u'color': u'red', u'name': u'lemon'}
+        ]
+        job_info_to_return = {u'jobs': jobs}
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+        self.assertEqual(self.j.jobs_count(), 3)
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_create.py

@@ -0,0 +1,61 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsCreateJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            jenkins.NotFoundException(),
+            None,
+            json.dumps({'name': 'Test Job'}),
+        ]
+
+        self.j.create_job(u'Test Job', self.config_xml)
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/createItem?name=Test%20Job')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_already_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'TestJob'}),
+            None,
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_job(u'TestJob', self.config_xml)
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/api/json?tree=name')
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] already exists')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            jenkins.NotFoundException(),
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_job(u'TestJob', self.config_xml)
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/api/json?tree=name')
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/createItem?name=TestJob')
+        self.assertEqual(
+            str(context_manager.exception),
+            'create[TestJob] failed')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_debug.py

@@ -0,0 +1,25 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsDebugJobInfoTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_debug_job_info(self, jenkins_mock):
+        job_info_to_return = {
+            u'building': False,
+            u'msg': u'test',
+            u'revision': 66,
+            u'user': u'unknown'
+        }
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+
+        self.j.debug_job_info(u'Test Job')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/api/json?depth=0')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_delete.py

@@ -0,0 +1,40 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsDeleteJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        self.j.delete_job(u'Test Job')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/Test%20Job/doDelete')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'TestJob'}),
+            json.dumps({'name': 'TestJob'}),
+            json.dumps({'name': 'TestJob'}),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.delete_job(u'TestJob')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/doDelete')
+        self.assertEqual(
+            str(context_manager.exception),
+            'delete[TestJob] failed')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_disable.py

@@ -0,0 +1,23 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsDisableJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'Test Job'}),
+            json.dumps({'name': 'Test Job'}),
+        ]
+
+        self.j.disable_job(u'Test Job')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/Test%20Job/disable')
+        self.assertTrue(self.j.job_exists('Test Job'))
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_enable.py

@@ -0,0 +1,23 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsEnableJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'TestJob'}),
+            json.dumps({'name': 'TestJob'}),
+        ]
+
+        self.j.enable_job(u'TestJob')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/enable')
+        self.assertTrue(self.j.job_exists('TestJob'))
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_get.py

@@ -0,0 +1,26 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsGetJobsTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jobs = {
+            u'url': u'http://your_url_here/job/my_job/',
+            u'color': u'blue',
+            u'name': u'my_job',
+        }
+        job_info_to_return = {u'jobs': jobs}
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+
+        job_info = self.j.get_jobs()
+
+        self.assertEqual(job_info, jobs)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_info.py

@@ -0,0 +1,93 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsGetJobInfoTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        job_info_to_return = {
+            u'building': False,
+            u'msg': u'test',
+            u'revision': 66,
+            u'user': u'unknown'
+        }
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+
+        job_info = self.j.get_job_info(u'Test Job')
+
+        self.assertEqual(job_info, job_info_to_return)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/api/json?depth=0')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_regex(self, jenkins_mock):
+        jobs = [
+            {u'name': u'my-job-1'},
+            {u'name': u'my-job-2'},
+            {u'name': u'your-job-1'},
+            {u'name': u'Your-Job-1'},
+            {u'name': u'my-project-1'},
+        ]
+        job_info_to_return = {u'jobs': jobs}
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+
+        self.assertEqual(len(self.j.get_job_info_regex('her-job')), 0)
+        self.assertEqual(len(self.j.get_job_info_regex('my-job-1')), 1)
+        self.assertEqual(len(self.j.get_job_info_regex('my-job')), 2)
+        self.assertEqual(len(self.j.get_job_info_regex('job')), 3)
+        self.assertEqual(len(self.j.get_job_info_regex('project')), 1)
+        self.assertEqual(len(self.j.get_job_info_regex('[Yy]our-[Jj]ob-1')), 2)
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.return_value = None
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_job_info(u'TestJob')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/TestJob/api/json?depth=0')
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'Invalid JSON'
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_job_info(u'TestJob')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/TestJob/api/json?depth=0')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for job[TestJob]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob/api/json?depth=0',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_job_info(u'TestJob')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/TestJob/api/json?depth=0')
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_name.py

@@ -0,0 +1,49 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsGetJobNameTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        job_name_to_return = {u'name': 'Test Job'}
+        jenkins_mock.return_value = json.dumps(job_name_to_return)
+
+        job_name = self.j.get_job_name(u'Test Job')
+
+        self.assertEqual(job_name, 'Test Job')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/api/json?tree=name')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.NotFoundException()
+
+        job_name = self.j.get_job_name(u'TestJob')
+
+        self.assertEqual(job_name, None)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/TestJob/api/json?tree=name')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_unexpected_job_name(self, jenkins_mock):
+        job_name_to_return = {u'name': 'not the right name'}
+        jenkins_mock.return_value = json.dumps(job_name_to_return)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_job_name(u'TestJob')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/api/json?tree=name')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Jenkins returned an unexpected job name {0} '
+            '(expected: {1})'.format(job_name_to_return['name'], 'TestJob'))
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_reconfig.py

@@ -0,0 +1,21 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsReconfigJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'Test Job'}),
+            None,
+        ]
+
+        self.j.reconfig_job(u'Test Job', self.config_xml)
+
+        self.assertEqual(jenkins_mock.call_args[0][0].get_full_url(),
+                         u'http://example.com/job/Test%20Job/config.xml')
+        self._check_requests(jenkins_mock.call_args_list)

tests/jobs/test_rename.py

@@ -0,0 +1,41 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.jobs.base import JenkinsJobsTestBase
+
+
+class JenkinsRenameJobTest(JenkinsJobsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'Test Job_2'}),
+            json.dumps({'name': 'Test Job_2'}),
+            json.dumps({'name': 'Test Job_2'}),
+        ]
+
+        self.j.rename_job(u'Test Job', u'Test Job_2')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/Test%20Job/doRename?newName=Test%20Job_2')
+        self.assertTrue(self.j.job_exists('Test Job_2'))
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.rename_job(u'TestJob', u'TestJob_2')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/job/TestJob/doRename?newName=TestJob_2')
+        self.assertEqual(
+            str(context_manager.exception),
+            'rename[TestJob_2] failed')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_build.py

@@ -0,0 +1,129 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsBuildConsoleTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.return_value = "build console output..."
+
+        build_info = self.j.get_build_console_output(u'Test Job', number=52)
+
+        self.assertEqual(build_info, jenkins_mock.return_value)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/52/consoleText')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.return_value = None
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_build_console_output(u'TestJob', number=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] number[52] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'Invalid JSON'
+
+        console_output = self.j.get_build_console_output(u'TestJob', number=52)
+        self.assertEqual(console_output, jenkins_mock.return_value)
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob/52/consoleText',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_build_console_output(u'TestJob', number=52)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/TestJob/52/consoleText')
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] number[52] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsBuildInfoTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        build_info_to_return = {
+            u'building': False,
+            u'msg': u'test',
+            u'revision': 66,
+            u'user': u'unknown'
+        }
+        jenkins_mock.return_value = json.dumps(build_info_to_return)
+
+        build_info = self.j.get_build_info(u'Test Job', number=52)
+
+        self.assertEqual(build_info, build_info_to_return)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/52/api/json?depth=0')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.return_value = None
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_build_info(u'TestJob', number=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] number[52] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'Invalid JSON'
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_build_info(u'TestJob', number=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for job[TestJob] number[52]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob/api/json?depth=0',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_build_info(u'TestJob', number=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'job[TestJob] number[52] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsStopBuildTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        self.j.stop_build(u'Test Job', number=52)
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/job/Test%20Job/52/stop')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_info.py

@@ -0,0 +1,91 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsInfoTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        job_info_to_return = {
+            u'jobs': {
+                u'url': u'http://your_url_here/job/my_job/',
+                u'color': u'blue',
+                u'name': u'my_job',
+            }
+        }
+        jenkins_mock.return_value = json.dumps(job_info_to_return)
+
+        job_info = self.j.get_info()
+
+        self.assertEqual(job_info, job_info_to_return)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob/api/json?depth=0',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_BadStatusLine(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.BadStatusLine('not a valid status line')
+
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'not valid JSON'
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_empty_response(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.JenkinsException(
+            "Error communicating with server[http://example.com/]: "
+            "empty response")
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]: '
+            'empty response')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_node.py

@@ -0,0 +1,325 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsNodesTestBase(JenkinsTestBase):
+
+    def setUp(self):
+        super(JenkinsNodesTestBase, self).setUp()
+        self.node_info = {
+            'displayName': 'test node',
+            'totalExecutors': 5,
+        }
+        self.online_node_info = dict(self.node_info)
+        self.online_node_info['offline'] = False
+        self.offline_node_info = dict(self.node_info)
+        self.offline_node_info['offline'] = True
+
+
+class JenkinsGetNodesTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps({
+            "computer": [{
+                "displayName": "master",
+                "offline": False
+            }],
+            "busyExecutors": 2})
+        self.assertEqual(self.j.get_nodes(),
+                         [{'name': 'master', 'offline': False}])
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            'Invalid JSON',
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_nodes()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch('jenkins.urlopen')
+    def test_raise_BadStatusLine(self, urlopen_mock):
+        urlopen_mock.side_effect = jenkins.BadStatusLine('not a valid status line')
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_nodes()
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(urlopen_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_nodes()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/api/json')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsGetNodeInfoTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.node_info),
+        ]
+
+        self.assertEqual(self.j.get_node_info('test node'), self.node_info)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test%20node/api/json?depth=0')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            'Invalid JSON',
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_node_info('test_node')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test_node/api/json?depth=0')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for node[test_node]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/TestJob',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_node_info('test_node')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test_node/api/json?depth=0')
+        self.assertEqual(
+            str(context_manager.exception),
+            'node[test_node] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsAssertNodeExistsTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_node_missing(self, jenkins_mock):
+        jenkins_mock.side_effect = [None]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.assert_node_exists('NonExistentNode')
+        self.assertEqual(
+            str(context_manager.exception),
+            'node[NonExistentNode] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_node_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'ExistingNode'})
+        ]
+        self.j.assert_node_exists('ExistingNode')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsDeleteNodeTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.node_info),
+            None,
+            None,
+            None,
+        ]
+
+        self.j.delete_node('test node')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/computer/test%20node/doDelete')
+        self.assertFalse(self.j.node_exists('test node'))
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.node_info),
+            None,
+            json.dumps(self.node_info),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.delete_node('test_node')
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/computer/test_node/doDelete')
+        self.assertEqual(
+            str(context_manager.exception),
+            'delete[test_node] failed')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsCreateNodeTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            None,
+            json.dumps(self.node_info),
+            json.dumps(self.node_info),
+        ]
+
+        self.j.create_node('test node', exclusive=True)
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url().split('?')[0],
+            'http://example.com/computer/doCreateItem')
+        self.assertTrue(self.j.node_exists('test node'))
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_already_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.node_info),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_node('test_node')
+        self.assertEqual(
+            str(context_manager.exception),
+            'node[test_node] already exists')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            None,
+            None,
+            None,
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_node('test_node')
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url().split('?')[0],
+            'http://example.com/computer/doCreateItem')
+        self.assertEqual(
+            str(context_manager.exception),
+            'create[test_node] failed')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsEnableNodeTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.offline_node_info),
+            None,
+        ]
+
+        self.j.enable_node('test node')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test%20node/' +
+            'toggleOffline?offlineMessage=')
+
+        jenkins_mock.side_effect = [json.dumps(self.online_node_info)]
+        node_info = self.j.get_node_info('test node')
+        self.assertEqual(node_info, self.online_node_info)
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_offline_false(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.online_node_info),
+            None,
+        ]
+
+        self.j.enable_node('test_node')
+
+        # Node was not offline; so enable_node skips toggle
+        # Last call to jenkins was to check status
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test_node/api/json?depth=0')
+
+        jenkins_mock.side_effect = [json.dumps(self.online_node_info)]
+        node_info = self.j.get_node_info('test_node')
+        self.assertEqual(node_info, self.online_node_info)
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsDisableNodeTest(JenkinsNodesTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.online_node_info),
+            None,
+        ]
+
+        self.j.disable_node('test node')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test%20node/' +
+            'toggleOffline?offlineMessage=')
+
+        jenkins_mock.side_effect = [json.dumps(self.offline_node_info)]
+        node_info = self.j.get_node_info('test node')
+        self.assertEqual(node_info, self.offline_node_info)
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_offline_true(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps(self.offline_node_info),
+            None,
+        ]
+
+        self.j.disable_node('test_node')
+
+        # Node was already offline; so disable_node skips toggle
+        # Last call to jenkins was to check status
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            'http://example.com/computer/test_node/api/json?depth=0')
+
+        jenkins_mock.side_effect = [json.dumps(self.offline_node_info)]
+        node_info = self.j.get_node_info('test_node')
+        self.assertEqual(node_info, self.offline_node_info)
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_plugins.py

@@ -0,0 +1,193 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsPluginsBase(JenkinsTestBase):
+
+    plugin_info_json = {
+        u"plugins":
+        [
+            {
+                u"active": u'true',
+                u"backupVersion": u'null',
+                u"bundled": u'true',
+                u"deleted": u'false',
+                u"dependencies": [],
+                u"downgradable": u'false',
+                u"enabled": u'true',
+                u"hasUpdate": u'true',
+                u"longName": u"Jenkins Mailer Plugin",
+                u"pinned": u'false',
+                u"shortName": u"mailer",
+                u"supportsDynamicLoad": u"MAYBE",
+                u"url": u"http://wiki.jenkins-ci.org/display/JENKINS/Mailer",
+                u"version": u"1.5"
+            }
+        ]
+    }
+
+
+class JenkinsPluginsInfoTest(JenkinsPluginsBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        # expected to return a list of plugins
+        plugins_info = self.j.get_plugins_info()
+        self.assertEqual(plugins_info, self.plugin_info_json['plugins'])
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=2')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        empty_plugin_info_json = {u"plugins": []}
+
+        jenkins_mock.return_value = json.dumps(empty_plugin_info_json)
+
+        plugins_info = self.j.get_plugins_info()
+        self.assertEqual(plugins_info, [])
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_depth(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        self.j.get_plugins_info(depth=1)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=1')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_BadStatusLine(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.BadStatusLine('not a valid status line')
+
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_plugins_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=2')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'not valid JSON'
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_plugins_info()
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=2')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/pluginManager/api/json?depth=2',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_plugins_info(depth=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsPluginInfoTest(JenkinsPluginsBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_shortname(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        # expected to return info on a single plugin
+        plugin_info = self.j.get_plugin_info("mailer")
+        self.assertEqual(plugin_info, self.plugin_info_json['plugins'][0])
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_longname(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        # expected to return info on a single plugin
+        plugin_info = self.j.get_plugin_info("Jenkins Mailer Plugin")
+        self.assertEqual(plugin_info, self.plugin_info_json['plugins'][0])
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        # expected not to find bogus so should return None
+        plugin_info = self.j.get_plugin_info("bogus")
+        self.assertEqual(plugin_info, None)
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_depth(self, jenkins_mock):
+        jenkins_mock.return_value = json.dumps(self.plugin_info_json)
+
+        self.j.get_plugin_info('test', depth=1)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=1')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_BadStatusLine(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.BadStatusLine('not a valid status line')
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_plugin_info('test')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=2')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_invalid_json(self, jenkins_mock):
+        jenkins_mock.return_value = 'not valid JSON'
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_plugin_info('test')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/pluginManager/api/json?depth=2')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Could not parse JSON info for server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_raise_HTTPError(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/job/pluginManager/api/json?depth=2',
+            code=401,
+            msg="basic auth failed",
+            hdrs=[],
+            fp=None)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_plugin_info(u'TestPlugin', depth=52)
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_queue.py

@@ -0,0 +1,72 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsCancelQueueTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        job_name_to_return = {u'name': 'TestJob'}
+        jenkins_mock.return_value = json.dumps(job_name_to_return)
+
+        self.j.cancel_queue(52)
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/queue/cancelItem?id=52')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open',
+                  side_effect=jenkins.NotFoundException('not found'))
+    def test_notfound(self, jenkins_mock):
+        job_name_to_return = {u'name': 'TestJob'}
+        jenkins_mock.return_value = json.dumps(job_name_to_return)
+
+        self.j.cancel_queue(52)
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/queue/cancelItem?id=52')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsQueueInfoTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        queue_info_to_return = {
+            'items': {
+                u'task': {
+                    u'url': u'http://your_url/job/my_job/',
+                    u'color': u'aborted_anime',
+                    u'name': u'my_job'
+                },
+                u'stuck': False,
+                u'actions': [
+                    {
+                        u'causes': [
+                            {
+                                u'shortDescription': u'Started by timer',
+                            },
+                        ],
+                    },
+                ],
+                u'buildable': False,
+                u'params': u'',
+                u'buildableStartMilliseconds': 1315087293316,
+                u'why': u'Build #2,532 is already in progress (ETA:10 min)',
+                u'blocked': True,
+            }
+        }
+        jenkins_mock.return_value = json.dumps(queue_info_to_return)
+
+        queue_info = self.j.get_queue_info()
+
+        self.assertEqual(queue_info, queue_info_to_return['items'])
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/queue/api/json?depth=0')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_script.py

@@ -0,0 +1,16 @@
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsScriptTest(JenkinsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_run_script(self, jenkins_mock):
+        self.j.run_script(u'println(\"Hello World!\")')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/scriptText')
+        self._check_requests(jenkins_mock.call_args_list)

tests/test_version.py

@@ -0,0 +1,57 @@
+from mock import patch, Mock
+import six
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsVersionTest(JenkinsTestBase):
+
+    @patch('jenkins.urlopen')
+    def test_some_version(self, urlopen_mock):
+        mock_response = Mock()
+        if six.PY2:
+            config = {'info.return_value.getheader.return_value': 'Version42'}
+
+        if six.PY3:
+            config = {'getheader.return_value': 'Version42'}
+
+        mock_response.configure_mock(**config)
+        urlopen_mock.side_effect = [mock_response]
+        self.assertEqual(self.j.get_version(), 'Version42')
+        self._check_requests(urlopen_mock.call_args_list)
+
+    @patch('jenkins.urlopen')
+    def test_raise_HTTPError(self, urlopen_mock):
+        urlopen_mock.side_effect = jenkins.HTTPError(
+            'http://example.com/',
+            code=503,
+            msg="internal server error",
+            hdrs=[],
+            fp=None)
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_version()
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(urlopen_mock.call_args_list)
+
+    @patch('jenkins.urlopen')
+    def test_raise_BadStatusLine(self, urlopen_mock):
+        urlopen_mock.side_effect = jenkins.BadStatusLine('not a valid status line')
+        with self.assertRaises(jenkins.BadHTTPException) as context_manager:
+            self.j.get_version()
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]')
+        self._check_requests(urlopen_mock.call_args_list)
+
+    @patch('jenkins.urlopen', return_value=None)
+    def test_return_empty_response(self, urlopen_mock):
+        with self.assertRaises(jenkins.EmptyResponseException) as context_manager:
+            self.j.get_version()
+        self.assertEqual(
+            str(context_manager.exception),
+            'Error communicating with server[http://example.com/]:'
+            ' empty response')
+        self._check_requests(urlopen_mock.call_args_list)

tests/test_view.py

@@ -0,0 +1,218 @@
+import json
+from mock import patch
+
+import jenkins
+from tests.base import JenkinsTestBase
+
+
+class JenkinsViewsTestBase(JenkinsTestBase):
+    config_xml = """
+        <listView>
+            <description>Foo</description>
+            <jobNames />
+        </listView>"""
+
+
+class JenkinsGetViewNameTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        view_name_to_return = {u'name': 'Test View'}
+        jenkins_mock.return_value = json.dumps(view_name_to_return)
+
+        view_name = self.j.get_view_name(u'Test View')
+
+        self.assertEqual(view_name, 'Test View')
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/view/Test%20View/api/json?tree=name')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_return_none(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.NotFoundException()
+
+        view_name = self.j.get_view_name(u'TestView')
+
+        self.assertEqual(view_name, None)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/view/TestView/api/json?tree=name')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_unexpected_view_name(self, jenkins_mock):
+        view_name_to_return = {u'name': 'not the right name'}
+        jenkins_mock.return_value = json.dumps(view_name_to_return)
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.get_view_name(u'TestView')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/view/TestView/api/json?tree=name')
+        self.assertEqual(
+            str(context_manager.exception),
+            'Jenkins returned an unexpected view name {0} '
+            '(expected: {1})'.format(view_name_to_return['name'], 'TestView'))
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsAssertViewTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_view_missing(self, jenkins_mock):
+        jenkins_mock.side_effect = jenkins.NotFoundException()
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.assert_view_exists('NonExistent')
+        self.assertEqual(
+            str(context_manager.exception),
+            'view[NonExistent] does not exist')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_view_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'ExistingView'}),
+        ]
+        self.j.assert_view_exists('ExistingView')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsGetViewsTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        views = {
+            u'url': u'http://your_url_here/view/my_view/',
+            u'name': u'my_view',
+        }
+        view_info_to_return = {u'views': views}
+        jenkins_mock.return_value = json.dumps(view_info_to_return)
+
+        view_info = self.j.get_views()
+
+        self.assertEqual(view_info, views)
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/api/json')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsDeleteViewTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        self.j.delete_view(u'Test View')
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/view/Test%20View/doDelete')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'TestView'}),
+            json.dumps({'name': 'TestView'}),
+            json.dumps({'name': 'TestView'}),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.delete_view(u'TestView')
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/view/TestView/doDelete')
+        self.assertEqual(
+            str(context_manager.exception),
+            'delete[TestView] failed')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsCreateViewTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            jenkins.NotFoundException(),
+            None,
+            json.dumps({'name': 'Test View'}),
+        ]
+
+        self.j.create_view(u'Test View', self.config_xml)
+
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/createView?name=Test%20View')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_already_exists(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'TestView'}),
+            None,
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_view(u'TestView', self.config_xml)
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/view/TestView/api/json?tree=name')
+        self.assertEqual(
+            str(context_manager.exception),
+            'view[TestView] already exists')
+        self._check_requests(jenkins_mock.call_args_list)
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_failed(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            jenkins.NotFoundException(),
+            None,
+            jenkins.NotFoundException(),
+        ]
+
+        with self.assertRaises(jenkins.JenkinsException) as context_manager:
+            self.j.create_view(u'TestView', self.config_xml)
+        self.assertEqual(
+            jenkins_mock.call_args_list[0][0][0].get_full_url(),
+            'http://example.com/view/TestView/api/json?tree=name')
+        self.assertEqual(
+            jenkins_mock.call_args_list[1][0][0].get_full_url(),
+            'http://example.com/createView?name=TestView')
+        self.assertEqual(
+            str(context_manager.exception),
+            'create[TestView] failed')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsReconfigViewTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_simple(self, jenkins_mock):
+        jenkins_mock.side_effect = [
+            json.dumps({'name': 'Test View'}),
+            None,
+        ]
+
+        self.j.reconfig_view(u'Test View', self.config_xml)
+
+        self.assertEqual(jenkins_mock.call_args[0][0].get_full_url(),
+                         u'http://example.com/view/Test%20View/config.xml')
+        self._check_requests(jenkins_mock.call_args_list)
+
+
+class JenkinsGetViewConfigTest(JenkinsViewsTestBase):
+
+    @patch.object(jenkins.Jenkins, 'jenkins_open')
+    def test_encodes_view_name(self, jenkins_mock):
+        self.j.get_view_config(u'Test View')
+
+        self.assertEqual(
+            jenkins_mock.call_args[0][0].get_full_url(),
+            u'http://example.com/view/Test%20View/config.xml')
+        self._check_requests(jenkins_mock.call_args_list)