--- /dev/null
+.PHONY: install
+
+install:
+ python3 setup.py install --prefix=${DESTDIR}/usr
+
Section: python
Priority: optional
Maintainer: Al Stone <ahs3@debian.org>
-Build-Depends: debhelper (>= 8.0.0), dh-python, python-dev, python-all-dev, python-lxml, python-setuptools
+Build-Depends: debhelper (>= 8.0.0), dh-python, python3, python3-all-dev, python3-lxml, python3-setuptools,
+ python3-pbr, python3-pytest, python3-pylint-common, python3-mock
XS-Python-Version: current
Standards-Version: 3.9.5
Homepage: http://pypi.python.org/pypi/jenkinsapi
-Package: python-jenkinsapi
+Package: python3-jenkinsapi
Architecture: all
-Depends: python-lxml, python-bs4, python-pkg-resources, python-requests,
- ${python:Depends}, ${misc:Depends}
-Provides: ${python:Provides}
-XB-Python-Versions: ${python:Versions}
+Depends: python3-lxml, python3-bs4, python3-pkg-resources, python3-requests,
+ ${python3:Depends}, ${misc:Depends}
+Provides: ${python3:Provides}
+XB-Python-Versions: ${python3:Versions}
Description: bindings for Python usage of the Jenkins remote API
Jenkins is the market leading continuous integration system, originally
created by Kohsuke Kawaguchi. This API makes Jenkins even easier to use
#export DH_VERBOSE=1
%:
- dh $@ --with python2
+ dh $@ --with python3 --buildsystem=pybuild
+
+override_dh_auto_test:
+ #disable test
+
+
master_doc = 'index'
# General information about the project.
-project = u' JenkinsAPI'
-copyright = u'2012, %s' % PROJECT_AUTHORS
+project = ' JenkinsAPI'
+copyright = '2012, %s' % PROJECT_AUTHORS
# The version info for the project you're documenting, acts as replacement for
# built documents.
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
- ('index', 'JenkinsAPI.tex', u'JenkinsAPI Documentation', u'xxx', 'manual'),
+ ('index', 'JenkinsAPI.tex', 'JenkinsAPI Documentation', 'xxx', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
- ('index', 'jenkinsapi', u' JenkinsAPI Documentation', [u'xxx'], 1)
+ ('index', 'jenkinsapi', ' JenkinsAPI Documentation', ['xxx'], 1)
]
# If true, show URL addresses after external links.
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
- ('index', 'JenkinsAPI', u'JenkinsAPI Documentation',
- u'xxx', 'JenkinsAPI', 'One line description of project.',
+ ('index', 'JenkinsAPI', 'JenkinsAPI Documentation',
+ 'xxx', 'JenkinsAPI', 'One line description of project.',
'Miscellaneous'),
]
command = ET.SubElement(shell, 'command')
command.text = "ls"
-print ET.tostring(root)
+print(ET.tostring(root))
J[jobname].update_config(ET.tostring(root))
#J.delete_job(jobname)
-from __future__ import print_function
+
import logging
logging.basicConfig()
# This example requires NestedViews plugin to be installed in Jenkins
# You need to have at least one job in your Jenkins to see views
-from __future__ import print_function
+
import logging
from pkg_resources import resource_string
else:
logger.info('View has been created')
-print('top_view.views=', top_view.views.keys())
+print('top_view.views=', list(top_view.views.keys()))
logger.info('Attempting to create view inside nested view')
sub_view = top_view.views.create('SubView')
if sub_view is None:
j = Jenkins('http://localhost:8080')
-for node_id, _ in j.get_nodes().iteritems():
+for node_id, _ in j.get_nodes().items():
if not node_id == 'master':
print(node_id)
j.delete_node(node_id)
"""
An example of how to use JenkinsAPI to fetch the config XML of a job.
"""
-from __future__ import print_function
+
from jenkinsapi.jenkins import Jenkins
J = Jenkins('http://localhost:8080')
"""
Get information about currently installed plugins
"""
-from __future__ import print_function
+
from jenkinsapi.jenkins import Jenkins
"""
Extract version information from the latest build.
"""
-from __future__ import print_function
+
from jenkinsapi.jenkins import Jenkins
-from __future__ import print_function
+
from jenkinsapi.view import View
from jenkinsapi.jenkins import Jenkins
J = Jenkins('http://localhost:8080')
-print(J.items())
+print(list(J.items()))
j = J['foo']
j = J.get_job("foo")
b = j.get_last_build()
-from __future__ import print_function
+
from jenkinsapi.api import search_artifact_by_regexp
import re
-from __future__ import print_function
+
from jenkinsapi.api import search_artifacts
"""
A lower-level implementation of copying a job in Jenkins
"""
-from __future__ import print_function
+
import requests
from jenkinsapi.jenkins import Jenkins
A low level example:
This is how JenkinsAPI creates views
"""
-from __future__ import print_function
+
import requests
import json
-from __future__ import print_function
+
import json
import requests
"""
A lower level example of how we login with authentication
"""
-from __future__ import print_function
+
from jenkinsapi import jenkins
J = jenkins.Jenkins("http://localhost:8080", username="sal", password="foobar")
J.poll()
-print(J.items())
+print(list(J.items()))
"""
-import SimpleHTTPServer
-import SocketServer
+import http.server
+import socketserver
import logging
import cgi
I = "localhost"
-class ServerHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+class ServerHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
logging.warning("======= GET STARTED =======")
logging.warning(self.headers)
- SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
+ http.server.SimpleHTTPRequestHandler.do_GET(self)
def do_POST(self):
logging.warning("======= POST STARTED =======")
for item in form.list:
logging.warning(item)
logging.warning("\n")
- SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
+ http.server.SimpleHTTPRequestHandler.do_GET(self)
Handler = ServerHandler
-httpd = SocketServer.TCPServer(("", PORT), Handler)
+httpd = socketserver.TCPServer(("", PORT), Handler)
-print "Serving at: http://%(interface)s:%(port)s" % dict(interface=I or "localhost", port=PORT)
+print("Serving at: http://%(interface)s:%(port)s" % dict(interface=I or "localhost", port=PORT))
httpd.serve_forever()
\ No newline at end of file
build = job.get_last_good_build()
artifacts = build.get_artifact_dict()
log.info(msg="Found %i artifacts in '%s'"
- % (len(artifacts.keys()), build_no))
+ % (len(list(artifacts.keys())), build_no))
return artifacts
"""
assert basestaticurl.endswith("/"), "Basestaticurl should end with /"
installed = []
- for reldir, artifactnames in dirstruct.items():
+ for reldir, artifactnames in list(dirstruct.items()):
destdir = os.path.join(installdir, reldir)
if not os.path.exists(destdir):
log.warn(msg="Making install directory %s" % destdir)
assert os.path.isdir(destdir)
for artifactname in artifactnames:
destpath = os.path.abspath(os.path.join(destdir, artifactname))
- if artifactname in artifacts.keys():
+ if artifactname in list(artifacts.keys()):
# The artifact must be loaded from jenkins
theartifact = artifacts[artifactname]
else:
artifacts = build.get_artifact_dict()
try:
- it = artifacts.iteritems()
+ it = iter(artifacts.items())
except AttributeError:
# Python3
- it = artifacts.items()
+ it = list(artifacts.items())
for name, art in it:
md_match = artifactRegExp.search(name)
import json
try:
- import urlparse
- from urllib import quote as urlquote, urlencode
+ import urllib.parse
+ from urllib.parse import quote as urlquote, urlencode
except ImportError:
# Python3
import urllib.parse as urlparse
return list(self.get_jobs())
def keys(self):
- return [a for a in self.iterkeys()]
+ return [a for a in self.keys()]
# This is a function alias we retain for historical compatibility
get_jobs_list = keys
def get_node_url(self, nodename=""):
"""Return the url for nodes"""
- url = urlparse.urljoin(self.base_server_url(), 'computer/%s' % urlquote(nodename))
+ url = urllib.parse.urljoin(self.base_server_url(), 'computer/%s' % urlquote(nodename))
return url
def get_queue_url(self):
def resolve_job_folders(self, jobs):
for job in list(jobs):
- if 'color' not in job.keys():
+ if 'color' not in list(job.keys()):
jobs.remove(job)
jobs += self.process_job_folder(job)
result = []
for job in data.get('jobs', []):
- if 'color' not in job.keys():
+ if 'color' not in list(job.keys()):
result += self.process_job_folder(job)
else:
result.append(job)
try:
- import urlparse
+ import urllib.parse
except ImportError:
# Python3
import urllib.parse as urlparse
out = {'parameter': build_p}
if file_params:
file_p = [{'name': k, 'file': k}
- for k in file_params.keys()]
+ for k in list(file_params.keys())]
out['parameter'].extend(file_p)
if len(out['parameter']) == 1:
# Either copy the params dict or make a new one.
build_params = build_params and dict(
- build_params.items()) or {} # Via POSTed JSON
+ list(build_params.items())) or {} # Via POSTed JSON
url = self.get_build_triggerurl(files)
if cause:
"""
url = self.get_config_xml_url()
try:
- if isinstance(config, unicode): # pylint: disable=undefined-variable
+ if isinstance(config, str): # pylint: disable=undefined-variable
config = str(config)
except NameError:
# Python3 already a str
if not self.is_queued():
raise NotInQueue()
queue_id = self._data['queueItem']['id']
- url = urlparse.urljoin(self.get_jenkins_obj().get_queue().baseurl,
+ url = urllib.parse.urljoin(self.get_jenkins_obj().get_queue().baseurl,
'cancelItem?id=%s' % queue_id)
self.get_jenkins_obj().requester.post_and_confirm_status(url, data='')
return True
"""
True if job_name is the name of a defined job
"""
- return job_name in self.keys()
+ return job_name in list(self.keys())
def iterkeys(self):
"""
"""
Return a list of the names of all jobs
"""
- return list(self.iterkeys())
+ return list(self.keys())
def create(self, job_name, config):
"""
params = {'name': job_name}
try:
- if isinstance(config, unicode): # pylint: disable=undefined-variable
+ if isinstance(config, str): # pylint: disable=undefined-variable
config = str(config)
except NameError:
# Python3 already a str
import logging
try:
- from urllib import quote as urlquote
+ from urllib.parse import quote as urlquote
except ImportError:
# Python3
from urllib.parse import quote as urlquote
return 'Nodes @ %s' % self.baseurl
def __contains__(self, node_name):
- return node_name in self.keys()
+ return node_name in list(self.keys())
def iterkeys(self):
for item in self._data['computer']:
yield item['displayName']
def keys(self):
- return list(self.iterkeys())
+ return list(self.keys())
def iteritems(self):
for item in self._data['computer']:
yield item['displayName'], Node(nodeurl, nodename, self.jenkins)
def __getitem__(self, nodename):
- self_as_dict = dict(self.iteritems())
+ self_as_dict = dict(iter(self.items()))
if nodename in self_as_dict:
return self_as_dict[nodename]
else:
raise UnknownNode(nodename)
def __len__(self):
- return len(self.iteritems())
+ return len(iter(self.items()))
"""
jenkinsapi plugins
"""
-from __future__ import print_function
+
import logging
from jenkinsapi.plugin import Plugin
return self.get_data(self.baseurl, tree=tree)
def keys(self):
- return self.get_plugins_dict().keys()
+ return list(self.get_plugins_dict().keys())
__iter__ = keys
return self._get_plugins()
def values(self):
- return [a[1] for a in self.iteritems()]
+ return [a[1] for a in self.items()]
def _get_plugins(self):
if 'plugins' in self._data:
return dict(self._get_plugins())
def __len__(self):
- return len(self.get_plugins_dict().keys())
+ return len(list(self.get_plugins_dict().keys()))
def __getitem__(self, plugin_name):
try:
"""
True if plugin_name is the name of a defined plugin
"""
- return plugin_name in self.keys()
+ return plugin_name in list(self.keys())
def __str__(self):
plugins = [plugin["shortName"] for plugin in self._data.get("plugins", [])]
yield QueueItem(self.jenkins, **item)
def keys(self):
- return list(self.iterkeys())
+ return list(self.keys())
def values(self):
- return list(self.itervalues())
+ return list(self.values())
def __len__(self):
return len(self._data['items'])
def __getitem__(self, item_id):
- self_as_dict = dict(self.iteritems())
+ self_as_dict = dict(iter(self.items()))
if item_id in self_as_dict:
return self_as_dict[item_id]
else:
return str(self)
def keys(self):
- return [a[0] for a in self.iteritems()]
+ return [a[0] for a in self.items()]
def items(self):
- return [a for a in self.iteritems()]
+ return [a for a in self.items()]
def iteritems(self):
for suite in self._data.get("suites", []):
yield result.identifier(), result
def __len__(self):
- return len(self.items())
+ return len(list(self.items()))
def __getitem__(self, key):
- self_as_dict = dict(self.iteritems())
+ self_as_dict = dict(iter(self.items()))
return self_as_dict[key]
import requests
try:
- import urlparse
+ import urllib.parse
except ImportError:
# Python3
import urllib.parse as urlparse
if username:
assert password, 'Cannot set a username without a password!'
- self.base_scheme = urlparse.urlsplit(baseurl).scheme if baseurl else None
+ self.base_scheme = urllib.parse.urlsplit(baseurl).scheme if baseurl else None
self.username = username
self.password = password
self.ssl_verify = ssl_verify
Updates scheme of given url to the one used in Jenkins baseurl.
"""
if self.base_scheme and not url.startswith("%s://" % self.base_scheme):
- url_split = urlparse.urlsplit(url)
- url = urlparse.urlunsplit(
+ url_split = urllib.parse.urlsplit(url)
+ url = urllib.parse.urlunsplit(
[
self.base_scheme,
url_split.netloc,
Module for jenkinsapi views
"""
try:
- from urllib import urlencode
+ from urllib.parse import urlencode
except ImportError:
# Python3
from urllib.parse import urlencode
"""
True if view_name is the name of a defined view
"""
- return job_name in self.keys()
+ return job_name in list(self.keys())
def delete(self):
"""
self.deleted = True
def keys(self):
- return self.get_job_dict().keys()
+ return list(self.get_job_dict().keys())
def iteritems(self):
try:
- it = self.get_job_dict().iteritems()
+ it = iter(self.get_job_dict().items())
except AttributeError:
# Python3
- it = self.get_job_dict().items()
+ it = list(self.get_job_dict().items())
for name, url in it:
api_url = self.python_api_url(url)
yield name, Job(api_url, name, self.jenkins_obj)
def values(self):
- return [a[1] for a in self.iteritems()]
+ return [a[1] for a in self.items()]
def items(self):
- return [a for a in self.iteritems()]
+ return [a for a in self.items()]
def _get_jobs(self):
if 'jobs' in self._data:
return dict(self._get_jobs())
def __len__(self):
- return len(self.get_job_dict().keys())
+ return len(list(self.get_job_dict().keys()))
def get_job_url(self, str_job_name):
if str_job_name in self:
return self.get_job_dict()[str_job_name]
else:
# noinspection PyUnboundLocalVariable
- views_jobs = ", ".join(self.get_job_dict().keys())
+ views_jobs = ", ".join(list(self.get_job_dict().keys()))
raise NotFound("Job %s is not known, available jobs"
" in view are: %s" % (str_job_name, views_jobs))
}
data["name"] = self.name
# Add existing jobs (if any)
- for job_name in self.get_job_dict().keys():
+ for job_name in list(self.get_job_dict().keys()):
data[job_name] = 'on'
# Add new job
"""
url = self.get_config_xml_url()
try:
- if isinstance(config, unicode): # pylint: disable=undefined-variable
+ if isinstance(config, str): # pylint: disable=undefined-variable
config = str(config)
except NameError:
# Python3 already a str
self.jenkins = jenkins
def __len__(self):
- return len(self.keys())
+ return len(list(self.keys()))
def __delitem__(self, view_name):
if view_name == 'All':
"""
True if view_name is the name of a defined view
"""
- return view_name in self.keys()
+ return view_name in list(self.keys())
def iterkeys(self):
"""
"""
Return a list of the names of all views
"""
- return list(self.iterkeys())
+ return list(self.keys())
def create(self, view_name, view_type=LIST_VIEW):
"""
def _delete_all_jobs(self):
self.jenkins.poll()
- for name in self.jenkins.keys():
+ for name in list(self.jenkins.keys()):
del self.jenkins[name]
def _delete_all_views(self):
- all_view_names = self.jenkins.views.keys()[1:]
+ all_view_names = list(self.jenkins.views.keys())[1:]
for name in all_view_names:
del self.jenkins.views[name]
"""
Can we keep track of the relationships between upstream & downstream jobs?
"""
- for job_name, job_config in JOB_CONFIGS.items():
+ for job_name, job_config in list(JOB_CONFIGS.items()):
self.jenkins.create_job(job_name, job_config)
self.jenkins['A'].invoke()
self.assertIsInstance(qq, QueueItem)
# Let Jenkins catchup
qq.block_until_building()
- self.assertEquals(qq.get_build_number(), 1)
+ self.assertEqual(qq.get_build_number(), 1)
def test_get_block_until_build_running(self):
job_name = 'Bcreate_%s' % random_string()
ii.block_until_complete(delay=2)
build_number = job.get_last_good_buildnumber()
- self.assertEquals(build_number, 3)
+ self.assertEqual(build_number, 3)
build = job.get_build(build_number)
self.assertIsInstance(build, Build)
qq = job.invoke()
qq.block_until_complete(delay=1)
build_number = qq.get_build_number()
- self.assertEquals(build_number, invocation + 1)
+ self.assertEqual(build_number, invocation + 1)
def test_give_params_on_non_parameterized_job(self):
job_name = 'Ecreate_%s' % random_string()
j.invoke(block=True) # run this at least once
j.disable()
- self.assertEquals(j.is_enabled(), False, 'A disabled job is reporting incorrectly')
+ self.assertEqual(j.is_enabled(), False, 'A disabled job is reporting incorrectly')
j.enable()
- self.assertEquals(j.is_enabled(), True, 'An enabled job is reporting incorrectly')
+ self.assertEqual(j.is_enabled(), True, 'An enabled job is reporting incorrectly')
def test_get_job_and_update_config(self):
job_name = 'config_%s' % random_string()
self.jenkins.create_job(job_name, EMPTY_JOB)
self.assertJobIsPresent(job_name)
config = self.jenkins[job_name].get_config()
- self.assertEquals(config.strip(), EMPTY_JOB.strip())
+ self.assertEqual(config.strip(), EMPTY_JOB.strip())
self.jenkins[job_name].update_config(EMPTY_JOB)
def test_invoke_job(self):
self.assertJobIsPresent(template_job_name)
self.assertJobIsPresent(copied_job_name)
self.assertIsInstance(j, Job)
- self.assertEquals(j.name, copied_job_name)
+ self.assertEqual(j.name, copied_job_name)
def test_get_master_data(self):
master_data = self.jenkins.get_master_data()
- self.assertEquals(master_data['totalExecutors'], 2)
+ self.assertEqual(master_data['totalExecutors'], 2)
def test_get_missing_plugin(self):
plugins = self.jenkins.get_plugins()
def test_get_single_plugin(self):
plugins = self.jenkins.get_plugins()
- plugin_name, plugin = next(plugins.iteritems())
+ plugin_name, plugin = next(iter(plugins.items()))
self.assertIsInstance(plugin_name, str)
self.assertIsInstance(plugin, Plugin)
def test_get_single_plugin_depth_2(self):
plugins = self.jenkins.get_plugins(depth=2)
- _, plugin = next(plugins.iteritems())
+ _, plugin = next(iter(plugins.items()))
if __name__ == '__main__':
unittest.main()
set_of_groups = set()
for run in build.get_matrix_runs():
- self.assertEquals(run.get_number(), build.get_number())
- self.assertEquals(run.get_upstream_build(), build)
- match_result = re.search(u'\xbb (.*) #\\d+$', run.name)
+ self.assertEqual(run.get_number(), build.get_number())
+ self.assertEqual(run.get_upstream_build(), build)
+ match_result = re.search('\xbb (.*) #\\d+$', run.name)
self.assertIsNotNone(match_result)
set_of_groups.add(match_result.group(1))
build.get_master_job_name()
self.assertTrue(self.jenkins.has_node(node_name))
N = self.jenkins.get_node(node_name)
- self.assertEquals(N.baseurl, self.jenkins.get_node_url(node_name))
+ self.assertEqual(N.baseurl, self.jenkins.get_node_url(node_name))
finally:
self.jenkins.delete_node(node_name)
except ImportError:
import unittest
try:
- from StringIO import StringIO
+ from io import StringIO
except ImportError:
from io import StringIO
from jenkinsapi_tests.systests.base import BaseSystemTest
reprString = repr(queue)
self.assertIn(queue.baseurl, reprString)
- for _, item in queue.iteritems():
+ for _, item in queue.items():
queue.delete_item(item)
queue.poll()
- self.assertEquals(len(queue), 0)
+ self.assertEqual(len(queue), 0)
def test_start_and_stop_long_running_job(self):
job_name = random_string()
# Can we use the API convenience methods
v2 = get_view_from_url(v.baseurl)
- self.assertEquals(v, v2)
+ self.assertEqual(v, v2)
def test_create_and_delete_views(self):
self._create_job()
self.assertIn(view_name, self.jenkins.views)
config = self.jenkins.views[view_name].get_config().strip()
new_view_config = VIEW_WITH_FILTER_AND_REGEX % view_name
- self.assertNotEquals(config, new_view_config)
+ self.assertNotEqual(config, new_view_config)
self.jenkins.views[view_name].update_config(new_view_config)
config = self.jenkins.views[view_name].get_config().strip()
- self.assertEquals(config, new_view_config)
+ self.assertEqual(config, new_view_config)
def test_make_nested_views(self):
job = self._create_job()
# Can we use the API convenience methods
v = get_view_from_url(sv2.baseurl)
- self.assertEquals(v, sv2)
+ self.assertEqual(v, sv2)
if __name__ == '__main__':
logging.basicConfig()
-from __future__ import print_function
+
import random
import string
import pytz
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
def testName(self):
with self.assertRaises(AttributeError):
self.b.id()
- self.assertEquals(self.b.name, 'foo #1')
+ self.assertEqual(self.b.name, 'foo #1')
def test_duration(self):
expected = datetime.timedelta(milliseconds=5782)
- self.assertEquals(self.b.get_duration(), expected)
- self.assertEquals(self.b.get_duration().seconds, 5)
- self.assertEquals(self.b.get_duration().microseconds, 782000)
- self.assertEquals(str(self.b.get_duration()), '0:00:05.782000')
+ self.assertEqual(self.b.get_duration(), expected)
+ self.assertEqual(self.b.get_duration().seconds, 5)
+ self.assertEqual(self.b.get_duration().microseconds, 782000)
+ self.assertEqual(str(self.b.get_duration()), '0:00:05.782000')
def test_get_causes(self):
- self.assertEquals(self.b.get_causes(),
+ self.assertEqual(self.b.get_causes(),
[{'shortDescription': 'Started by user anonymous',
'userId': None,
'userName': 'anonymous'}])
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
Can we extract git build revision data from a build object?
"""
try:
- self.assertIsInstance(self.b.get_revision(), basestring)
+ self.assertIsInstance(self.b.get_revision(), str)
except NameError:
# Python3
self.assertIsInstance(self.b.get_revision(), str)
- self.assertEquals(self.b.get_revision(),
+ self.assertEqual(self.b.get_revision(),
'7def9ed6e92580f37d00e4980c36c4d36e68f702')
def test_git_revision_branch(self):
Can we extract git build branch from a build object?
"""
self.assertIsInstance(self.b.get_revision_branch(), list)
- self.assertEquals(len(self.b.get_revision_branch()), 1)
+ self.assertEqual(len(self.b.get_revision_branch()), 1)
self.assertIsInstance(self.b.get_revision_branch()[0], dict)
- self.assertEquals(self.b.get_revision_branch()[0]['SHA1'],
+ self.assertEqual(self.b.get_revision_branch()[0]['SHA1'],
'7def9ed6e92580f37d00e4980c36c4d36e68f702')
- self.assertEquals(self.b.get_revision_branch()[0]['name'],
+ self.assertEqual(self.b.get_revision_branch()[0]['name'],
'origin/unstable')
if __name__ == '__main__':
-import mock
+from unittest import mock
import types
# To run unittests on python 2.6 please use unittest2 library
try:
assert repr(self.J)
def testCheckURL(self):
- self.assertEquals(self.J.baseurl, 'http://localhost:8080')
+ self.assertEqual(self.J.baseurl, 'http://localhost:8080')
@mock.patch.object(Executors, '_poll')
@mock.patch.object(Executor, '_poll')
self.assertIsInstance(repr(exec_info), str)
for e in exec_info:
- self.assertEquals(e.get_progress(), 48, 'Should return 48 %')
+ self.assertEqual(e.get_progress(), 48, 'Should return 48 %')
@mock.patch.object(Executors, '_poll')
@mock.patch.object(Executor, '_poll')
self.assertIsInstance(exec_info, object)
for e in exec_info:
- self.assertEquals(e.get_progress(), -1, 'Should return 48 %')
- self.assertEquals(e.is_idle(), True, 'Should return True')
- self.assertEquals(
+ self.assertEqual(e.get_progress(), -1, 'Should return 48 %')
+ self.assertEqual(e.is_idle(), True, 'Should return True')
+ self.assertEqual(
repr(e),
'<jenkinsapi.executor.Executor host3.host.com 0>'
)
baseurl = 'http://localhost:8080/computer/host0.host.com/executors/0'
nodename = 'host0.host.com'
single_executer = Executor(baseurl, nodename, self.J, '0')
- self.assertEquals(single_executer.likely_stuck(), False)
+ self.assertEqual(single_executer.likely_stuck(), False)
@mock.patch.object(Executor, '_poll')
def test_get_current_executable(self, _poll_executor):
baseurl = 'http://localhost:8080/computer/host0.host.com/executors/0'
nodename = 'host0.host.com'
single_executer = Executor(baseurl, nodename, self.J, '0')
- self.assertEquals(
+ self.assertEqual(
single_executer.get_current_executable()['number'],
4168
)
- self.assertEquals(
+ self.assertEqual(
single_executer.get_current_executable()['url'],
'http://localhost:8080/job/testjob/4168/'
)
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
J = Jenkins(self.baseurl, username='foouser', password='foopassword')
self.fp_instance = Fingerprint(self.baseurl, self.dummy_md5, J)
self.assertTrue(isinstance(self.fp_instance, Fingerprint))
- self.assertEquals(str(self.fp_instance), self.dummy_md5)
+ self.assertEqual(str(self.fp_instance), self.dummy_md5)
self.assertTrue(self.fp_instance.valid())
@mock.patch.object(Jenkins, '_poll')
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
def test_clone(self, _poll):
_poll.return_value = self.DATA
JJ = self.J._clone()
- self.assertNotEquals(id(JJ), id(self.J))
- self.assertEquals(JJ, self.J)
+ self.assertNotEqual(id(JJ), id(self.J))
+ self.assertEqual(JJ, self.J)
def test_stored_passwords(self):
- self.assertEquals(self.J.requester.password, 'foopassword')
- self.assertEquals(self.J.requester.username, 'foouser')
+ self.assertEqual(self.J.requester.password, 'foopassword')
+ self.assertEqual(self.J.requester.username, 'foouser')
@mock.patch.object(Jenkins, '_poll')
def test_reload(self, _poll):
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword')
for idx, (job_name, job) in enumerate(J.get_jobs()):
- self.assertEquals(job_name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(job_name, _poll.return_value['jobs'][idx]['name'])
self.assertTrue(isinstance(job, Job))
- self.assertEquals(job.name, _poll.return_value['jobs'][idx]['name'])
- self.assertEquals(job.baseurl, _poll.return_value['jobs'][idx]['url'])
+ self.assertEqual(job.name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(job.baseurl, _poll.return_value['jobs'][idx]['url'])
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword', lazy=True)
- self.assertEquals(J._data, None)
+ self.assertEqual(J._data, None)
for idx, (job_name, job) in enumerate(J.get_jobs()):
- self.assertEquals(job_name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(job_name, _poll.return_value['jobs'][idx]['name'])
self.assertTrue(isinstance(job, Job))
- self.assertEquals(job.name, _poll.return_value['jobs'][idx]['name'])
- self.assertEquals(job.baseurl, _poll.return_value['jobs'][idx]['url'])
+ self.assertEqual(job.name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(job.baseurl, _poll.return_value['jobs'][idx]['url'])
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword')
for idx, (url, job_name) in enumerate(J.get_jobs_info()):
- self.assertEquals(job_name, _poll.return_value['jobs'][idx]['name'])
- self.assertEquals(url, _poll.return_value['jobs'][idx]['url'])
+ self.assertEqual(job_name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(url, _poll.return_value['jobs'][idx]['url'])
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword')
for idx, job_name in enumerate(J.get_jobs_list()):
- self.assertEquals(job_name, _poll.return_value['jobs'][idx]['name'])
+ self.assertEqual(job_name, _poll.return_value['jobs'][idx]['name'])
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
username='foouser', password='foopassword')
job = J.get_job('job_one')
self.assertTrue(isinstance(job, Job))
- self.assertEquals(job.name, _poll.return_value['jobs'][0]['name'])
- self.assertEquals(job.baseurl, _poll.return_value['jobs'][0]['url'])
+ self.assertEqual(job.name, _poll.return_value['jobs'][0]['name'])
+ self.assertEqual(job.baseurl, _poll.return_value['jobs'][0]['url'])
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
with self.assertRaises(JenkinsAPIException) as ar:
J.create_job('job_new', None)
- self.assertEquals(str(ar.exception), 'Cannot create job job_new')
+ self.assertEqual(str(ar.exception), 'Cannot create job job_new')
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
requester=mock_requester)
new_jenkins = J.get_jenkins_obj_from_url('http://localhost:8080/')
- self.assertEquals(new_jenkins, J)
+ self.assertEqual(new_jenkins, J)
new_jenkins = J.get_jenkins_obj_from_url('http://localhost:8080/foo')
- self.assertNotEquals(new_jenkins, J)
+ self.assertNotEqual(new_jenkins, J)
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
requester=mock_requester)
new_jenkins = J.get_jenkins_obj()
- self.assertEquals(new_jenkins, J)
+ self.assertEqual(new_jenkins, J)
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword',
requester=mock_requester)
- self.assertEquals('1.542', J.version)
+ self.assertEqual('1.542', J.version)
@mock.patch.object(JenkinsBase, '_poll')
@mock.patch.object(Jenkins, '_poll')
J = Jenkins(base_url,
username='foouser', password='foopassword',
requester=mock_requester)
- self.assertEquals('0.0', J.version)
+ self.assertEqual('0.0', J.version)
@mock.patch.object(JenkinsBase, 'get_data')
def test_get_master_data(self, _base_poll):
j = Jenkins(base_url,
username='foouser', password='foopassword')
data = j.get_master_data()
- self.assertEquals(data['busyExecutors'], 59)
- self.assertEquals(data['totalExecutors'], 75)
+ self.assertEqual(data['busyExecutors'], 59)
+ self.assertEqual(data['totalExecutors'], 75)
class TestJenkinsURLs(unittest.TestCase):
_poll.return_value = {}
J = Jenkins('http://localhost:8080',
username='foouser', password='foopassword')
- self.assertEquals(J.get_create_url(), 'http://localhost:8080/createItem')
+ self.assertEqual(J.get_create_url(), 'http://localhost:8080/createItem')
@mock.patch.object(Jenkins, '_poll')
def testWithSlash(self, _poll):
_poll.return_value = {}
J = Jenkins('http://localhost:8080/',
username='foouser', password='foopassword')
- self.assertEquals(J.get_create_url(), 'http://localhost:8080/createItem')
+ self.assertEqual(J.get_create_url(), 'http://localhost:8080/createItem')
@mock.patch.object(Jenkins, '_poll')
@mock.patch.object(Plugins, '_poll')
-import mock
+from unittest import mock
import json
# To run unittests on python 2.6 please use unittest2 library
try:
def testRepr(self):
# Can we produce a repr string for this object
- self.assertEquals(repr(self.j), '<jenkinsapi.job.Job foo>')
+ self.assertEqual(repr(self.j), '<jenkinsapi.job.Job foo>')
def testName(self):
with self.assertRaises(AttributeError):
self.j.id()
- self.assertEquals(self.j.name, 'foo')
+ self.assertEqual(self.j.name, 'foo')
def testNextBuildNumber(self):
- self.assertEquals(self.j.get_next_build_number(), 4)
+ self.assertEqual(self.j.get_next_build_number(), 4)
def test_special_urls(self):
- self.assertEquals(self.j.baseurl, 'http://halob:8080/job/foo')
+ self.assertEqual(self.j.baseurl, 'http://halob:8080/job/foo')
- self.assertEquals(
+ self.assertEqual(
self.j.get_delete_url(), 'http://halob:8080/job/foo/doDelete')
- self.assertEquals(
+ self.assertEqual(
self.j.get_rename_url(), 'http://halob:8080/job/foo/doRename')
def test_get_description(self):
- self.assertEquals(self.j.get_description(), 'test job')
+ self.assertEqual(self.j.get_description(), 'test job')
def test_get_build_triggerurl(self):
- self.assertEquals(self.j.get_build_triggerurl(None),
+ self.assertEqual(self.j.get_build_triggerurl(None),
'http://halob:8080/job/foo/buildWithParameters')
def test_wrong__mk_json_from_build_parameters(self):
with self.assertRaises(AssertionError) as ar:
self.j._mk_json_from_build_parameters(build_params='bad parameter')
- self.assertEquals(
+ self.assertEqual(
str(ar.exception), 'Build parameters must be a dict')
@mock.patch.object(JenkinsBase, 'get_data', fakeGetData)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetData)
def test_get_last_buildnumber(self):
ret = self.j.get_last_buildnumber()
- self.assertEquals(ret, 4)
+ self.assertEqual(ret, 4)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetData)
def test_get_last_completed_buildnumber(self):
ret = self.j.get_last_completed_buildnumber()
- self.assertEquals(ret, 3)
+ self.assertEqual(ret, 3)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
def test_get_build_dict(self):
ret = self.j.get_build_dict()
self.assertTrue(isinstance(ret, dict))
- self.assertEquals(len(ret), 4)
+ self.assertEqual(len(ret), 4)
@mock.patch.object(JenkinsBase, 'get_data', fake_get_data_tree_empty)
def test_nobuilds_get_build_dict(self):
# So we convert result to a list
ret = list(self.j.get_build_ids())
self.assertTrue(isinstance(ret, list))
- self.assertEquals(len(ret), 4)
+ self.assertEqual(len(ret), 4)
@mock.patch.object(Job, '_poll')
def test_nobuilds_get_revision_dict(self, _poll):
mock_data = TestJob.URL_DATA[url].copy()
mock_data['firstBuild'] = {'number': 1}
del mock_data['builds'][-1]
- self.assertEquals(len(mock_data['builds']), 2)
+ self.assertEqual(len(mock_data['builds']), 2)
new_data = j._add_missing_builds(mock_data)
- self.assertEquals(len(new_data['builds']), 3)
+ self.assertEqual(len(new_data['builds']), 3)
@mock.patch.object(JenkinsBase, 'get_data')
def test__add_missing_builds_no_first_build(self, get_data):
mock_data = TestJob.URL_DATA[url].copy()
mock_data['firstBuild'] = None
j._add_missing_builds(mock_data)
- self.assertEquals(initial_call_count, get_data.call_count)
+ self.assertEqual(initial_call_count, get_data.call_count)
@mock.patch.object(JenkinsBase, 'get_data')
def test__add_missing_builds_no_builds(self, get_data):
mock_data = TestJob.URL_DATA[url].copy()
mock_data['builds'] = None
j._add_missing_builds(mock_data)
- self.assertEquals(initial_call_count, get_data.call_count)
+ self.assertEqual(initial_call_count, get_data.call_count)
@mock.patch.object(JenkinsBase, 'get_data')
def test_get_params(self, get_data):
get_data.return_value = TestJob.URL_DATA[url].copy()
j = Job('http://halob:8080/job/foo/', 'foo', self.J)
params = list(j.get_params())
- self.assertEquals(len(params), 2)
+ self.assertEqual(len(params), 2)
@mock.patch.object(JenkinsBase, 'get_data')
def test_get_params_list(self, get_data):
params = j.get_params_list()
self.assertIsInstance(params, list)
- self.assertEquals(len(params), 2)
- self.assertEquals(params, ['param1', 'param2'])
+ self.assertEqual(len(params), 2)
+ self.assertEqual(params, ['param1', 'param2'])
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
# @mock.patch.object(JenkinsBase, 'get_data', fakeGetLastBuild)
with mock.patch('jenkinsapi.job.Build') as build_mock:
instance = build_mock.return_value
build = self.j.get_build(buildnumber)
- self.assertEquals(build, instance)
+ self.assertEqual(build, instance)
build_mock.assert_called_with('http://halob:8080/job/foo/1/',
buildnumber, job=self.j)
with mock.patch('jenkinsapi.job.Build') as build_mock:
instance = build_mock.return_value
build = self.j.get_build_metadata(buildnumber)
- self.assertEquals(build, instance)
+ self.assertEqual(build, instance)
build_mock.assert_called_with('http://halob:8080/job/foo/1/',
buildnumber, job=self.j, depth=0)
result = self.j._mk_json_from_build_parameters(build_params=params)
self.assertTrue(isinstance(result, dict))
- self.assertEquals(
+ self.assertEqual(
result,
{"parameter": [{"name": "param1", "value": "value1"}, {
"name": "param2", "value": "value2"}]}
with self.assertRaises(AssertionError) as ar:
self.j.mk_json_from_build_parameters(build_params='bad parameter')
- self.assertEquals(
+ self.assertEqual(
str(ar.exception), 'Build parameters must be a dict')
if __name__ == '__main__':
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
},
]
- self.assertEquals(
+ self.assertEqual(
self.jb.resolve_job_folders(jobs),
[
{
},
]
- self.assertEquals(self.jb.resolve_job_folders(jobs), [])
+ self.assertEqual(self.jb.resolve_job_folders(jobs), [])
get_data_mock.assert_called_once_with('http://localhost:8080/job/Folder1/api/python')
@mock.patch('jenkinsapi.jenkins.JenkinsBase.get_data')
},
]
- self.assertEquals(
+ self.assertEqual(
self.jb.resolve_job_folders(jobs),
[
{
},
]
- self.assertEquals(
+ self.assertEqual(
self.jb.resolve_job_folders(jobs),
[
{
]
)
- self.assertEquals(
+ self.assertEqual(
get_data_mock.call_args_list,
[
mock.call('http://localhost:8080/job/Folder1/api/python'),
},
]
- self.assertEquals(
+ self.assertEqual(
self.jb.resolve_job_folders(jobs),
[
{
]
)
- self.assertEquals(
+ self.assertEqual(
get_data_mock.call_args_list,
[
mock.call('http://localhost:8080/job/Folder1/api/python'),
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
# remaining jobs will be fetched automatically
ret = self.j.get_build_dict()
self.assertTrue(isinstance(ret, dict))
- self.assertEquals(len(ret), 4)
+ self.assertEqual(len(ret), 4)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
def test_incomplete_builds_list_will_call_jenkins_twice(self):
# the Jenkins API
TestJobGetAllBuilds.__get_data_call_count = 0
self.j = Job('http://halob:8080/job/foo/', 'foo', self.J)
- self.assertEquals(TestJobGetAllBuilds.__get_data_call_count, 2)
+ self.assertEqual(TestJobGetAllBuilds.__get_data_call_count, 2)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
def test_complete_builds_list_will_call_jenkins_once(self):
# The job data contains all builds, so we will not gather remaining builds
TestJobGetAllBuilds.__get_data_call_count = 0
self.j = Job('http://halob:8080/job/fullfoo/', 'fullfoo', self.J)
- self.assertEquals(TestJobGetAllBuilds.__get_data_call_count, 1)
+ self.assertEqual(TestJobGetAllBuilds.__get_data_call_count, 1)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
def test_nobuilds_get_build_dict(self):
ret = j.get_build_dict()
self.assertTrue(isinstance(ret, dict))
- self.assertEquals(len(ret), 0)
+ self.assertEqual(len(ret), 0)
@mock.patch.object(JenkinsBase, 'get_data', fakeGetDataTree)
def test_get_build_ids(self):
# remaining jobs will be fetched automatically
ret = list(self.j.get_build_ids())
self.assertTrue(isinstance(ret, list))
- self.assertEquals(len(ret), 4)
+ self.assertEqual(len(ret), 4)
if __name__ == '__main__':
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
@mock.patch.object(Job,'get_config',configtree_with_branch)
def test_hg_attributes(self):
expected_url = ['http://cm5/hg/sandbox/v01.0/int']
- self.assertEquals(self.j.get_scm_type(),'hg')
- self.assertEquals(self.j.get_scm_url(),expected_url)
- self.assertEquals(self.j.get_scm_branch(),['testme'])
+ self.assertEqual(self.j.get_scm_type(),'hg')
+ self.assertEqual(self.j.get_scm_url(),expected_url)
+ self.assertEqual(self.j.get_scm_branch(),['testme'])
@mock.patch.object(Job,'get_config',configtree_with_default_branch)
def test_hg_attributes_default_branch(self):
- self.assertEquals(self.j.get_scm_branch(),['default'])
+ self.assertEqual(self.j.get_scm_branch(),['default'])
if __name__ == '__main__':
unittest.main()
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
def testName(self):
with self.assertRaises(AttributeError):
self.n.id()
- self.assertEquals(self.n.name, 'bobnit')
+ self.assertEqual(self.n.name, 'bobnit')
@mock.patch.object(Node, '_poll')
def test_online(self, _poll):
_poll.return_value = self.DATA
- return self.assertEquals(self.n.is_online(), True)
+ return self.assertEqual(self.n.is_online(), True)
if __name__ == '__main__':
unittest.main()
repr(self.ns)
def testCheckURL(self):
- self.assertEquals(self.ns.baseurl, 'http://localhost:8080/computer')
+ self.assertEqual(self.ns.baseurl, 'http://localhost:8080/computer')
@mock.patch.object(Node, '_poll')
def testGetMasterNode(self, _poll_node):
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
_poll_plugins.return_value = {}
plugins = self.J.get_plugins()
- self.assertEquals(str(plugins), "[]")
+ self.assertEqual(str(plugins), "[]")
@mock.patch.object(Plugins, '_poll')
def test_plugins_str(self, _poll_plugins):
_poll_plugins.return_value = self.DATA
plugins = self.J.get_plugins()
- self.assertEquals(str(plugins), "['maven-plugin', 'subversion']")
+ self.assertEqual(str(plugins), "['maven-plugin', 'subversion']")
@mock.patch.object(Plugins, '_poll')
def test_plugins_len(self, _poll_plugins):
_poll_plugins.return_value = self.DATA
plugins = self.J.get_plugins()
- self.assertEquals(len(plugins), 2)
+ self.assertEqual(len(plugins), 2)
@mock.patch.object(Plugins, '_poll')
def test_plugins_contains(self, _poll_plugins):
}
)
- plugins = self.J.get_plugins().values()
+ plugins = list(self.J.get_plugins().values())
self.assertIn(p, plugins)
@mock.patch.object(Plugins, '_poll')
def test_plugins_keys(self, _poll_plugins):
_poll_plugins.return_value = self.DATA
- plugins = self.J.get_plugins().keys()
+ plugins = list(self.J.get_plugins().keys())
self.assertIn('subversion', plugins)
self.assertIn('maven-plugin', plugins)
# list() is required here for python 3.x compatibility
plugins = list(self.J.get_plugins().keys())
- self.assertEquals([], plugins)
+ self.assertEqual([], plugins)
@mock.patch.object(Plugins, '_poll')
def test_plugin_get_by_name(self, _poll_plugins):
)
plugin = self.J.get_plugins()['subversion']
- self.assertEquals(p, plugin)
+ self.assertEqual(p, plugin)
@mock.patch.object(Plugins, '_poll')
def test_get_plugin_details(self, _poll_plugins):
_poll_plugins.return_value = self.DATA
plugin = self.J.get_plugins()['subversion']
- self.assertEquals('1.45', plugin.version)
- self.assertEquals('subversion', plugin.shortName)
- self.assertEquals('Jenkins Subversion Plug-in', plugin.longName)
- self.assertEquals('http://wiki.jenkins-ci.org/display/JENKINS/Subversion+Plugin',
+ self.assertEqual('1.45', plugin.version)
+ self.assertEqual('subversion', plugin.shortName)
+ self.assertEqual('Jenkins Subversion Plug-in', plugin.longName)
+ self.assertEqual('http://wiki.jenkins-ci.org/display/JENKINS/Subversion+Plugin',
plugin.url)
def test_plugin_repr(self):
'shortName': 'subversion',
}
)
- self.assertEquals(repr(p), '<jenkinsapi.plugin.Plugin subversion>')
+ self.assertEqual(repr(p), '<jenkinsapi.plugin.Plugin subversion>')
if __name__ == '__main__':
unittest.main()
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
self.assertTrue(repr(self.q))
def test_length(self):
- self.assertEquals(len(self.q), 3)
+ self.assertEqual(len(self.q), 3)
def test_list_items(self):
- self.assertEquals(set(self.q.keys()), set([40, 41, 42]))
+ self.assertEqual(set(self.q.keys()), set([40, 41, 42]))
@mock.patch.object(JenkinsBase, 'get_data', mockGetData)
def test_getitem(self):
def test_get_queue_item_for_job(self):
item40 = self.q.get_queue_items_for_job('klscuimkqo')
self.assertIsInstance(item40, list)
- self.assertEquals(len(item40), 1)
+ self.assertEqual(len(item40), 1)
self.assertIsInstance(item40[0], QueueItem)
@mock.patch.object(JenkinsBase, 'get_data', mockGetData)
def test_qi_get_parameters(self):
qi = self.q[42]
- self.assertEquals(qi.get_parameters(), {'name1': 'value1',
+ self.assertEqual(qi.get_parameters(), {'name1': 'value1',
'node': None})
-from __future__ import print_function
-
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
with self.assertRaises(AttributeError):
self.rs.id()
- self.assertEquals(self.rs.name, 'Test Result for FooBuild')
+ self.assertEqual(self.rs.name, 'Test Result for FooBuild')
def testBuildComponents(self):
- self.assertTrue(self.rs.items())
- for k, v in self.rs.items():
+ self.assertTrue(list(self.rs.items()))
+ for k, v in list(self.rs.items()):
self.assertIsInstance(k, str)
self.assertIsInstance(v, Result)
self.assertIsInstance(v.identifier(), str)
-import mock
+from unittest import mock
# To run unittests on python 2.6 please use unittest2 library
try:
import unittest2 as unittest
def testName(self):
with self.assertRaises(AttributeError):
self.v.id()
- self.assertEquals(self.v.name, 'FodFanFo')
+ self.assertEqual(self.v.name, 'FodFanFo')
@mock.patch.object(JenkinsBase, '_poll')
def test_iteritems(self, _poll):
_poll.return_value = self.JOB_DATA
- for job_name, job_obj in self.v.iteritems():
+ for job_name, job_obj in self.v.items():
self.assertTrue(isinstance(job_obj, Job))
def test_get_job_dict(self):
jobs = self.v.get_job_dict()
- self.assertEquals(jobs, {
+ self.assertEqual(jobs, {
'foo': 'http://halob:8080/job/foo/',
'test_jenkinsapi': 'http://halob:8080/job/test_jenkinsapi/'})
def test_len(self):
- self.assertEquals(len(self.v), 2)
+ self.assertEqual(len(self.v), 2)
# We have to re-patch JenkinsBase here because by the time
# it get to create Job, MagicMock will already expire
self.assertTrue(self.v.deleted)
def test_get_job_url(self):
- self.assertEquals(self.v.get_job_url('foo'), 'http://halob:8080/job/foo/')
+ self.assertEqual(self.v.get_job_url('foo'), 'http://halob:8080/job/foo/')
def test_wrong_get_job_url(self):
with self.assertRaises(NotFound):
def test_get_nested_view_dict(self):
result = self.v.get_nested_view_dict()
self.assertTrue(isinstance(result, dict))
- self.assertEquals(len(result), 0)
+ self.assertEqual(len(result), 0)
if __name__ == '__main__':
unittest.main()
new_view = J.views.create('NewView')
self.assertTrue(isinstance(new_view, View))
- self.assertEquals(new_view.baseurl,
+ self.assertEqual(new_view.baseurl,
'http://localhost:8080/views/NewView')
def test_create_existing_view(self):
import os
import time
try:
- import Queue
+ import queue
except ImportError:
import queue as Queue
import random
import subprocess
from pkg_resources import resource_string
try:
- from urlparse import urlparse
+ from urllib.parse import urlparse
except ImportError:
from urllib.parse import urlparse
self.war_directory, self.war_filename = os.path.split(self.war_path)
self.jenkins_home = tempfile.mkdtemp(prefix='jenkins-home-')
self.jenkins_process = None
- self.q = Queue.Queue()
+ self.q = queue.Queue()
self.plugin_urls = plugin_urls or []
def update_war(self):
# Python 3.x
if isinstance(line, bytes):
line = line.decode('UTF-8')
- except Queue.Empty:
+ except queue.Empty:
log.warn("Input ended unexpectedly")
break
else:
-from __future__ import print_function
-import SimpleHTTPServer
-import SocketServer
+
+import http.server
+import socketserver
import logging
import cgi
PORT = 8080
-class ServerHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+class ServerHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
logging.error(self.headers)
- SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
+ http.server.SimpleHTTPRequestHandler.do_GET(self)
def do_POST(self):
logging.error(self.headers)
})
for item in form.list:
logging.error(item)
- SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
+ http.server.SimpleHTTPRequestHandler.do_GET(self)
Handler = ServerHandler
-httpd = SocketServer.TCPServer(("", PORT), Handler)
+httpd = socketserver.TCPServer(("", PORT), Handler)
print("serving at port", PORT)
httpd.serve_forever()
-pip install wheel
-pip install mock
-pip install coverage
-pip install sphinx
+pip3 install wheel
+pip3 install mock
+pip3 install coverage
+pip3 install sphinx
ant release
git tag v`jenkinsapi_version`
ant doc
--- /dev/null
+pytz>=2014.4
+requests>=2.3.0
+six>=1.10.0
+
+[metadata]
+name = jenkinsapi
+author = Salim Fadhley, Aleksey Maksimov
+author_email = salimfadhley@gmail.com, ctpeko3a@gmail.com
+summary = A Python API for accessing resources on a Jenkins continuous-integration server.
+description-file = README.rst
+license = MIT
+classifier =
+ Development Status :: 4 - Beta
+ Environment :: Console
+ Intended Audience :: Developers
+ Intended Audience :: Information Technology
+ Intended Audience :: System Administrators
+ License :: OSI Approved :: MIT License
+ Natural Language :: English
+ Operating System :: OS Independent
+ Operating System :: OS Independent
+ Programming Language :: Python
+ Programming Language :: Python :: 2
+ Programming Language :: Python :: 2.7
+ Programming Language :: Python :: 3
+ Programming Language :: Python :: 3.4
+ Programming Language :: Python :: 3.5
+ Programming Language :: Python :: 3.6
+ Topic :: Software Development :: Testing
+ Topic :: Utilities
+
+[files]
+packages =
+ jenkinsapi
+ jenkinsapi_utils
+
+[pbr]
+warnerrors = True
+
+[entry_points]
+console_scripts =
+ jenkins_invoke=jenkinsapi.command_line.jenkins_invoke:main
+ jenkinsapi_version=jenkinsapi.command_line.jenkinsapi_version:main
+
[build_sphinx]
source-dir = doc/source
build-dir = doc/build
[upload_sphinx]
upload-dir = doc/build/html
-[nosetests]
-detailed-errors = 1
-with-coverage = 1
-cover-package = jenkinsapi
\ No newline at end of file
+[bdist_wheel]
+universal = 1
+
+[pycodestyle]
+exclude = .tox,doc/source/conf.py,build,.venv,.eggs
+max-line-length = 99
+
+[egg_info]
+tag_build =
+tag_date = 0
+
+
from setuptools import setup
-import os
-PROJECT_ROOT, _ = os.path.split(__file__)
-REVISION = '0.2.26'
-PROJECT_NAME = 'JenkinsAPI'
-PROJECT_AUTHORS = "Salim Fadhley, Aleksey Maksimov"
-# Please see readme.rst for a complete list of contributors
-PROJECT_EMAILS = 'salimfadhley@gmail.com, ctpeko3a@gmail.com'
-PROJECT_URL = "https://github.com/salimfadhley/jenkinsapi"
-SHORT_DESCRIPTION = 'A Python API for accessing resources on a Jenkins continuous-integration server.'
-
-try:
- DESCRIPTION = open(os.path.join(PROJECT_ROOT, "README.rst")).read()
-except IOError:
- DESCRIPTION = SHORT_DESCRIPTION
-
-GLOBAL_ENTRY_POINTS = {
- "console_scripts": ["jenkins_invoke=jenkinsapi.command_line.jenkins_invoke:main",
- "jenkinsapi_version=jenkinsapi.command_line.jenkinsapi_version:main"]
-}
setup(
- name=PROJECT_NAME.lower(),
- version=REVISION,
- author=PROJECT_AUTHORS,
- author_email=PROJECT_EMAILS,
- packages=['jenkinsapi', 'jenkinsapi.utils', 'jenkinsapi.command_line', 'jenkinsapi_tests'],
- zip_safe=True,
- include_package_data=False,
- install_requires=['requests>=2.3.0', 'pytz>=2014.4'],
- test_suite='nose.collector',
- tests_require=['mock', 'nose', 'coverage', 'unittest2'],
- entry_points=GLOBAL_ENTRY_POINTS,
- url=PROJECT_URL,
- description=SHORT_DESCRIPTION,
- long_description=DESCRIPTION,
- license='MIT',
- classifiers=[
- 'Development Status :: 4 - Beta',
- 'Environment :: Console',
- 'Intended Audience :: Developers',
- 'License :: OSI Approved :: MIT License',
- 'Natural Language :: English',
- 'Operating System :: OS Independent',
- 'Programming Language :: Python :: 2.7',
- 'Topic :: Software Development :: Testing',
- ],
-)
+ setup_requires=['pbr'],
+ pbr=True)
+
projects / tools / python-jenkinsapi.git / commitdiff