summaryrefslogtreecommitdiff
path: root/gitlab/tests
diff options
context:
space:
mode:
Diffstat (limited to 'gitlab/tests')
-rw-r--r--gitlab/tests/objects/test_application.py8
-rw-r--r--gitlab/tests/objects/test_commits.py16
-rw-r--r--gitlab/tests/objects/test_groups.py26
-rw-r--r--gitlab/tests/objects/test_projects.py70
-rw-r--r--gitlab/tests/test_base.py58
-rw-r--r--gitlab/tests/test_cli.py70
-rw-r--r--gitlab/tests/test_config.py81
-rw-r--r--gitlab/tests/test_exceptions.py5
-rw-r--r--gitlab/tests/test_gitlab.py335
-rw-r--r--gitlab/tests/test_mixins.py184
-rw-r--r--gitlab/tests/test_types.py24
-rw-r--r--gitlab/tests/test_utils.py8
12 files changed, 446 insertions, 439 deletions
diff --git a/gitlab/tests/objects/test_application.py b/gitlab/tests/objects/test_application.py
index 50ca1ad..a10691b 100644
--- a/gitlab/tests/objects/test_application.py
+++ b/gitlab/tests/objects/test_application.py
@@ -80,13 +80,13 @@ class TestApplicationAppearance(unittest.TestCase):
with HTTMock(resp_get_appearance), HTTMock(resp_update_appearance):
appearance = self.gl.appearance.get()
- self.assertEqual(appearance.title, self.title)
- self.assertEqual(appearance.description, self.description)
+ assert appearance.title == self.title
+ assert appearance.description == self.description
appearance.title = self.new_title
appearance.description = self.new_description
appearance.save()
- self.assertEqual(appearance.title, self.new_title)
- self.assertEqual(appearance.description, self.new_description)
+ assert appearance.title == self.new_title
+ assert appearance.description == self.new_description
def test_update_appearance(self):
@urlmatch(
diff --git a/gitlab/tests/objects/test_commits.py b/gitlab/tests/objects/test_commits.py
index 7e7c3b4..bf7d5a8 100644
--- a/gitlab/tests/objects/test_commits.py
+++ b/gitlab/tests/objects/test_commits.py
@@ -78,8 +78,8 @@ class TestCommit(TestProject):
@with_httmock(resp_get_commit)
def test_get_commit(self):
commit = self.project.commits.get("6b2257ea")
- self.assertEqual(commit.short_id, "6b2257ea")
- self.assertEqual(commit.title, "Initial commit")
+ assert commit.short_id == "6b2257ea"
+ assert commit.title == "Initial commit"
@with_httmock(resp_create_commit)
def test_create_commit(self):
@@ -89,19 +89,19 @@ class TestCommit(TestProject):
"actions": [{"action": "create", "file_path": "README", "content": "",}],
}
commit = self.project.commits.create(data)
- self.assertEqual(commit.short_id, "ed899a2f")
- self.assertEqual(commit.title, data["commit_message"])
+ assert commit.short_id == "ed899a2f"
+ assert commit.title == data["commit_message"]
@with_httmock(resp_revert_commit)
def test_revert_commit(self):
commit = self.project.commits.get("6b2257ea", lazy=True)
revert_commit = commit.revert(branch="master")
- self.assertEqual(revert_commit["short_id"], "8b090c1b")
- self.assertEqual(revert_commit["title"], 'Revert "Initial commit"')
+ assert revert_commit["short_id"] == "8b090c1b"
+ assert revert_commit["title"] == 'Revert "Initial commit"'
@with_httmock(resp_get_commit_gpg_signature)
def test_get_commit_gpg_signature(self):
commit = self.project.commits.get("6b2257ea", lazy=True)
signature = commit.signature()
- self.assertEqual(signature["gpg_key_primary_keyid"], "8254AAB3FBD54AC9")
- self.assertEqual(signature["verification_status"], "verified")
+ assert signature["gpg_key_primary_keyid"] == "8254AAB3FBD54AC9"
+ assert signature["verification_status"] == "verified"
diff --git a/gitlab/tests/objects/test_groups.py b/gitlab/tests/objects/test_groups.py
index 075d915..12ebdb2 100644
--- a/gitlab/tests/objects/test_groups.py
+++ b/gitlab/tests/objects/test_groups.py
@@ -48,18 +48,18 @@ class TestGroup(unittest.TestCase):
@with_httmock(resp_get_group)
def test_get_group(self):
data = self.gl.groups.get(1)
- self.assertIsInstance(data, gitlab.v4.objects.Group)
- self.assertEqual(data.name, "name")
- self.assertEqual(data.path, "path")
- self.assertEqual(data.id, 1)
+ assert isinstance(data, gitlab.v4.objects.Group)
+ assert data.name == "name"
+ assert data.path == "path"
+ assert data.id == 1
@with_httmock(resp_create_group)
def test_create_group(self):
name, path = "name", "path"
data = self.gl.groups.create({"name": name, "path": path})
- self.assertIsInstance(data, gitlab.v4.objects.Group)
- self.assertEqual(data.name, name)
- self.assertEqual(data.path, path)
+ assert isinstance(data, gitlab.v4.objects.Group)
+ assert data.name == name
+ assert data.path == path
class TestGroupExport(TestGroup):
@@ -70,32 +70,32 @@ class TestGroupExport(TestGroup):
@with_httmock(resp_create_export)
def test_create_group_export(self):
export = self.group.exports.create()
- self.assertEqual(export.message, "202 Accepted")
+ assert export.message == "202 Accepted"
@unittest.skip("GitLab API endpoint not implemented")
@with_httmock(resp_create_export)
def test_refresh_group_export_status(self):
export = self.group.exports.create()
export.refresh()
- self.assertEqual(export.export_status, "finished")
+ assert export.export_status == "finished"
@with_httmock(resp_create_export, resp_download_export)
def test_download_group_export(self):
export = self.group.exports.create()
download = export.download()
- self.assertIsInstance(download, bytes)
- self.assertEqual(download, binary_content)
+ assert isinstance(download, bytes)
+ assert download == binary_content
class TestGroupImport(TestGroup):
@with_httmock(resp_create_import)
def test_import_group(self):
group_import = self.gl.groups.import_group("file", "api-group", "API Group")
- self.assertEqual(group_import["message"], "202 Accepted")
+ assert group_import["message"] == "202 Accepted"
@unittest.skip("GitLab API endpoint not implemented")
@with_httmock(resp_create_import)
def test_refresh_group_import_status(self):
group_import = self.group.imports.get()
group_import.refresh()
- self.assertEqual(group_import.import_status, "finished")
+ assert group_import.import_status == "finished"
diff --git a/gitlab/tests/objects/test_projects.py b/gitlab/tests/objects/test_projects.py
index ca7e0c8..fa105ae 100644
--- a/gitlab/tests/objects/test_projects.py
+++ b/gitlab/tests/objects/test_projects.py
@@ -341,9 +341,9 @@ class TestProjectSnippets(TestProject):
with HTTMock(resp_list_snippet):
snippets = self.project.snippets.list()
- self.assertEqual(len(snippets), 1)
- self.assertEqual(snippets[0].title, title)
- self.assertEqual(snippets[0].visibility, visibility)
+ assert len(snippets) == 1
+ assert snippets[0].title == title
+ assert snippets[0].visibility == visibility
def test_get_project_snippets(self):
title = "Example Snippet Title"
@@ -370,8 +370,8 @@ class TestProjectSnippets(TestProject):
with HTTMock(resp_get_snippet):
snippet = self.project.snippets.get(1)
- self.assertEqual(snippet.title, title)
- self.assertEqual(snippet.visibility, visibility)
+ assert snippet.title == title
+ assert snippet.visibility == visibility
def test_create_update_project_snippets(self):
title = "Example Snippet Title"
@@ -424,107 +424,107 @@ class TestProjectSnippets(TestProject):
"visibility": visibility,
}
)
- self.assertEqual(snippet.title, title)
- self.assertEqual(snippet.visibility, visibility)
+ assert snippet.title == title
+ assert snippet.visibility == visibility
title = "new-title"
snippet.title = title
snippet.save()
- self.assertEqual(snippet.title, title)
- self.assertEqual(snippet.visibility, visibility)
+ assert snippet.title == title
+ assert snippet.visibility == visibility
class TestProjectExport(TestProject):
@with_httmock(resp_create_export)
def test_create_project_export(self):
export = self.project.exports.create()
- self.assertEqual(export.message, "202 Accepted")
+ assert export.message == "202 Accepted"
@with_httmock(resp_create_export, resp_export_status)
def test_refresh_project_export_status(self):
export = self.project.exports.create()
export.refresh()
- self.assertEqual(export.export_status, "finished")
+ assert export.export_status == "finished"
@with_httmock(resp_create_export, resp_download_export)
def test_download_project_export(self):
export = self.project.exports.create()
download = export.download()
- self.assertIsInstance(download, bytes)
- self.assertEqual(download, binary_content)
+ assert isinstance(download, bytes)
+ assert download == binary_content
class TestProjectImport(TestProject):
@with_httmock(resp_import_project)
def test_import_project(self):
project_import = self.gl.projects.import_project("file", "api-project")
- self.assertEqual(project_import["import_status"], "scheduled")
+ assert project_import["import_status"] == "scheduled"
@with_httmock(resp_import_status)
def test_refresh_project_import_status(self):
project_import = self.project.imports.get()
project_import.refresh()
- self.assertEqual(project_import.import_status, "finished")
+ assert project_import.import_status == "finished"
@with_httmock(resp_import_github)
def test_import_github(self):
base_path = "/root"
name = "my-repo"
ret = self.gl.projects.import_github("githubkey", 1234, base_path, name)
- self.assertIsInstance(ret, dict)
- self.assertEqual(ret["name"], name)
- self.assertEqual(ret["full_path"], "/".join((base_path, name)))
- self.assertTrue(ret["full_name"].endswith(name))
+ assert isinstance(ret, dict)
+ assert ret["name"] == name
+ assert ret["full_path"] == "/".join((base_path, name))
+ assert ret["full_name"].endswith(name)
class TestProjectRemoteMirrors(TestProject):
@with_httmock(resp_get_remote_mirrors)
def test_list_project_remote_mirrors(self):
mirrors = self.project.remote_mirrors.list()
- self.assertIsInstance(mirrors, list)
- self.assertIsInstance(mirrors[0], ProjectRemoteMirror)
- self.assertTrue(mirrors[0].enabled)
+ assert isinstance(mirrors, list)
+ assert isinstance(mirrors[0], ProjectRemoteMirror)
+ assert mirrors[0].enabled
@with_httmock(resp_create_remote_mirror)
def test_create_project_remote_mirror(self):
mirror = self.project.remote_mirrors.create({"url": "https://example.com"})
- self.assertIsInstance(mirror, ProjectRemoteMirror)
- self.assertEqual(mirror.update_status, "none")
+ assert isinstance(mirror, ProjectRemoteMirror)
+ assert mirror.update_status == "none"
@with_httmock(resp_create_remote_mirror, resp_update_remote_mirror)
def test_update_project_remote_mirror(self):
mirror = self.project.remote_mirrors.create({"url": "https://example.com"})
mirror.only_protected_branches = True
mirror.save()
- self.assertEqual(mirror.update_status, "finished")
- self.assertTrue(mirror.only_protected_branches)
+ assert mirror.update_status == "finished"
+ assert mirror.only_protected_branches
class TestProjectServices(TestProject):
@with_httmock(resp_get_active_services)
def test_list_active_services(self):
services = self.project.services.list()
- self.assertIsInstance(services, list)
- self.assertIsInstance(services[0], ProjectService)
- self.assertTrue(services[0].active)
- self.assertTrue(services[0].push_events)
+ assert isinstance(services, list)
+ assert isinstance(services[0], ProjectService)
+ assert services[0].active
+ assert services[0].push_events
def test_list_available_services(self):
services = self.project.services.available()
- self.assertIsInstance(services, list)
- self.assertIsInstance(services[0], str)
+ assert isinstance(services, list)
+ assert isinstance(services[0], str)
@with_httmock(resp_get_service)
def test_get_service(self):
service = self.project.services.get("pipelines-email")
- self.assertIsInstance(service, ProjectService)
- self.assertEqual(service.push_events, True)
+ assert isinstance(service, ProjectService)
+ assert service.push_events == True
@with_httmock(resp_get_service, resp_update_service)
def test_update_service(self):
service = self.project.services.get("pipelines-email")
service.issues_events = True
service.save()
- self.assertEqual(service.issues_events, True)
+ assert service.issues_events == True
class TestProjectPipelineSchedule(TestProject):
diff --git a/gitlab/tests/test_base.py b/gitlab/tests/test_base.py
index 5a43b1d..666060c 100644
--- a/gitlab/tests/test_base.py
+++ b/gitlab/tests/test_base.py
@@ -19,6 +19,7 @@ import pickle
import unittest
from gitlab import base
+import pytest
class FakeGitlab(object):
@@ -41,7 +42,7 @@ class TestRESTManager(unittest.TestCase):
_obj_cls = object
mgr = MGR(FakeGitlab())
- self.assertEqual(mgr._computed_path, "/tests")
+ assert mgr._computed_path == "/tests"
def test_computed_path_with_parent(self):
class MGR(base.RESTManager):
@@ -53,7 +54,7 @@ class TestRESTManager(unittest.TestCase):
id = 42
mgr = MGR(FakeGitlab(), parent=Parent())
- self.assertEqual(mgr._computed_path, "/tests/42/cases")
+ assert mgr._computed_path == "/tests/42/cases"
def test_path_property(self):
class MGR(base.RESTManager):
@@ -61,7 +62,7 @@ class TestRESTManager(unittest.TestCase):
_obj_cls = object
mgr = MGR(FakeGitlab())
- self.assertEqual(mgr.path, "/tests")
+ assert mgr.path == "/tests"
class TestRESTObject(unittest.TestCase):
@@ -72,54 +73,55 @@ class TestRESTObject(unittest.TestCase):
def test_instanciate(self):
obj = FakeObject(self.manager, {"foo": "bar"})
- self.assertDictEqual({"foo": "bar"}, obj._attrs)
- self.assertDictEqual({}, obj._updated_attrs)
- self.assertEqual(None, obj._create_managers())
- self.assertEqual(self.manager, obj.manager)
- self.assertEqual(self.gitlab, obj.manager.gitlab)
+ assert {"foo": "bar"} == obj._attrs
+ assert {} == obj._updated_attrs
+ assert None == obj._create_managers()
+ assert self.manager == obj.manager
+ assert self.gitlab == obj.manager.gitlab
def test_pickability(self):
obj = FakeObject(self.manager, {"foo": "bar"})
original_obj_module = obj._module
pickled = pickle.dumps(obj)
unpickled = pickle.loads(pickled)
- self.assertIsInstance(unpickled, FakeObject)
- self.assertTrue(hasattr(unpickled, "_module"))
- self.assertEqual(unpickled._module, original_obj_module)
+ assert isinstance(unpickled, FakeObject)
+ assert hasattr(unpickled, "_module")
+ assert unpickled._module == original_obj_module
pickled2 = pickle.dumps(unpickled)
def test_attrs(self):
obj = FakeObject(self.manager, {"foo": "bar"})
- self.assertEqual("bar", obj.foo)
- self.assertRaises(AttributeError, getattr, obj, "bar")
+ assert "bar" == obj.foo
+ with pytest.raises(AttributeError):
+ getattr(obj, "bar")
obj.bar = "baz"
- self.assertEqual("baz", obj.bar)
- self.assertDictEqual({"foo": "bar"}, obj._attrs)
- self.assertDictEqual({"bar": "baz"}, obj._updated_attrs)
+ assert "baz" == obj.bar
+ assert {"foo": "bar"} == obj._attrs
+ assert {"bar": "baz"} == obj._updated_attrs
def test_get_id(self):
obj = FakeObject(self.manager, {"foo": "bar"})
obj.id = 42
- self.assertEqual(42, obj.get_id())
+ assert 42 == obj.get_id()
obj.id = None
- self.assertEqual(None, obj.get_id())
+ assert None == obj.get_id()
def test_custom_id_attr(self):
class OtherFakeObject(FakeObject):
_id_attr = "foo"
obj = OtherFakeObject(self.manager, {"foo": "bar"})
- self.assertEqual("bar", obj.get_id())
+ assert "bar" == obj.get_id()
def test_update_attrs(self):
obj = FakeObject(self.manager, {"foo": "bar"})
obj.bar = "baz"
obj._update_attrs({"foo": "foo", "bar": "bar"})
- self.assertDictEqual({"foo": "foo", "bar": "bar"}, obj._attrs)
- self.assertDictEqual({}, obj._updated_attrs)
+ assert {"foo": "foo", "bar": "bar"} == obj._attrs
+ assert {} == obj._updated_attrs
def test_create_managers(self):
class ObjectWithManager(FakeObject):
@@ -127,14 +129,14 @@ class TestRESTObject(unittest.TestCase):
obj = ObjectWithManager(self.manager, {"foo": "bar"})
obj.id = 42
- self.assertIsInstance(obj.fakes, FakeManager)
- self.assertEqual(obj.fakes.gitlab, self.gitlab)
- self.assertEqual(obj.fakes._parent, obj)
+ assert isinstance(obj.fakes, FakeManager)
+ assert obj.fakes.gitlab == self.gitlab
+ assert obj.fakes._parent == obj
def test_equality(self):
obj1 = FakeObject(self.manager, {"id": "foo"})
obj2 = FakeObject(self.manager, {"id": "foo", "other_attr": "bar"})
- self.assertEqual(obj1, obj2)
+ assert obj1 == obj2
def test_equality_custom_id(self):
class OtherFakeObject(FakeObject):
@@ -142,14 +144,14 @@ class TestRESTObject(unittest.TestCase):
obj1 = OtherFakeObject(self.manager, {"foo": "bar"})
obj2 = OtherFakeObject(self.manager, {"foo": "bar", "other_attr": "baz"})
- self.assertEqual(obj1, obj2)
+ assert obj1 == obj2
def test_inequality(self):
obj1 = FakeObject(self.manager, {"id": "foo"})
obj2 = FakeObject(self.manager, {"id": "bar"})
- self.assertNotEqual(obj1, obj2)
+ assert obj1 != obj2
def test_inequality_no_id(self):
obj1 = FakeObject(self.manager, {"attr1": "foo"})
obj2 = FakeObject(self.manager, {"attr1": "bar"})
- self.assertNotEqual(obj1, obj2)
+ assert obj1 != obj2
diff --git a/gitlab/tests/test_cli.py b/gitlab/tests/test_cli.py
index 4820103..63a5793 100644
--- a/gitlab/tests/test_cli.py
+++ b/gitlab/tests/test_cli.py
@@ -37,12 +37,13 @@ except ImportError:
from gitlab import cli
import gitlab.v4.cli
+import pytest
class TestCLI(unittest.TestCase):
def test_what_to_cls(self):
- self.assertEqual("Foo", cli.what_to_cls("foo"))
- self.assertEqual("FooBar", cli.what_to_cls("foo-bar"))
+ assert "Foo" == cli.what_to_cls("foo")
+ assert "FooBar" == cli.what_to_cls("foo-bar")
def test_cls_to_what(self):
class Class(object):
@@ -51,64 +52,63 @@ class TestCLI(unittest.TestCase):
class TestClass(object):
pass
- self.assertEqual("test-class", cli.cls_to_what(TestClass))
- self.assertEqual("class", cli.cls_to_what(Class))
+ assert "test-class" == cli.cls_to_what(TestClass)
+ assert "class" == cli.cls_to_what(Class)
def test_die(self):
fl = io.StringIO()
with redirect_stderr(fl):
- with self.assertRaises(SystemExit) as test:
+ with pytest.raises(SystemExit) as test:
cli.die("foobar")
- self.assertEqual(fl.getvalue(), "foobar\n")
- self.assertEqual(test.exception.code, 1)
+ assert fl.getvalue() == "foobar\n"
+ assert test.value.code == 1
def test_parse_value(self):
ret = cli._parse_value("foobar")
- self.assertEqual(ret, "foobar")
+ assert ret == "foobar"
ret = cli._parse_value(True)
- self.assertEqual(ret, True)
+ assert ret == True
ret = cli._parse_value(1)
- self.assertEqual(ret, 1)
+ assert ret == 1
ret = cli._parse_value(None)
- self.assertEqual(ret, None)
+ assert ret == None
fd, temp_path = tempfile.mkstemp()
os.write(fd, b"content")
os.close(fd)
ret = cli._parse_value("@%s" % temp_path)
- self.assertEqual(ret, "content")
+ assert ret == "content"
os.unlink(temp_path)
fl = io.StringIO()
with redirect_stderr(fl):
- with self.assertRaises(SystemExit) as exc:
+ with pytest.raises(SystemExit) as exc:
cli._parse_value("@/thisfileprobablydoesntexist")
- self.assertEqual(
- fl.getvalue(),
- "[Errno 2] No such file or directory:"
- " '/thisfileprobablydoesntexist'\n",
+ assert (
+ fl.getvalue() == "[Errno 2] No such file or directory:"
+ " '/thisfileprobablydoesntexist'\n"
)
- self.assertEqual(exc.exception.code, 1)
+ assert exc.value.code == 1
def test_base_parser(self):
parser = cli._get_base_parser()
args = parser.parse_args(
["-v", "-g", "gl_id", "-c", "foo.cfg", "-c", "bar.cfg"]
)
- self.assertTrue(args.verbose)
- self.assertEqual(args.gitlab, "gl_id")
- self.assertEqual(args.config_file, ["foo.cfg", "bar.cfg"])
+ assert args.verbose
+ assert args.gitlab == "gl_id"
+ assert args.config_file == ["foo.cfg", "bar.cfg"]
class TestV4CLI(unittest.TestCase):
def test_parse_args(self):
parser = cli._get_parser(gitlab.v4.cli)
args = parser.parse_args(["project", "list"])
- self.assertEqual(args.what, "project")
- self.assertEqual(args.whaction, "list")
+ assert args.what == "project"
+ assert args.whaction == "list"
def test_parser(self):
parser = cli._get_parser(gitlab.v4.cli)
@@ -117,25 +117,25 @@ class TestV4CLI(unittest.TestCase):
for action in parser._actions
if isinstance(action, argparse._SubParsersAction)
)
- self.assertIsNotNone(subparsers)
- self.assertIn("project", subparsers.choices)
+ assert subparsers is not None
+ assert "project" in subparsers.choices
user_subparsers = next(
action
for action in subparsers.choices["project"]._actions
if isinstance(action, argparse._SubParsersAction)
)
- self.assertIsNotNone(user_subparsers)
- self.assertIn("list", user_subparsers.choices)
- self.assertIn("get", user_subparsers.choices)
- self.assertIn("delete", user_subparsers.choices)
- self.assertIn("update", user_subparsers.choices)
- self.assertIn("create", user_subparsers.choices)
- self.assertIn("archive", user_subparsers.choices)
- self.assertIn("unarchive", user_subparsers.choices)
+ assert user_subparsers is not None
+ assert "list" in user_subparsers.choices
+ assert "get" in user_subparsers.choices
+ assert "delete" in user_subparsers.choices
+ assert "update" in user_subparsers.choices
+ assert "create" in user_subparsers.choices
+ assert "archive" in user_subparsers.choices
+ assert "unarchive" in user_subparsers.choices
actions = user_subparsers.choices["create"]._option_string_actions
- self.assertFalse(actions["--description"].required)
+ assert not actions["--description"].required
user_subparsers = next(
action
@@ -143,4 +143,4 @@ class TestV4CLI(unittest.TestCase):
if isinstance(action, argparse._SubParsersAction)
)
actions = user_subparsers.choices["create"]._option_string_actions
- self.assertTrue(actions["--name"].required)
+ assert actions["--name"].required
diff --git a/gitlab/tests/test_config.py b/gitlab/tests/test_config.py
index 681b3d1..abdeed0 100644
--- a/gitlab/tests/test_config.py
+++ b/gitlab/tests/test_config.py
@@ -22,6 +22,7 @@ import mock
import io
from gitlab import config
+import pytest
valid_config = u"""[global]
@@ -76,18 +77,18 @@ per_page = 200
class TestEnvConfig(unittest.TestCase):
def test_env_present(self):
with mock.patch.dict(os.environ, {"PYTHON_GITLAB_CFG": "/some/path"}):
- self.assertEqual(["/some/path"], config._env_config())
+ assert ["/some/path"] == config._env_config()
def test_env_missing(self):
with mock.patch.dict(os.environ, {}, clear=True):
- self.assertEqual([], config._env_config())
+ assert [] == config._env_config()
class TestConfigParser(unittest.TestCase):
@mock.patch("os.path.exists")
def test_missing_config(self, path_exists):
path_exists.return_value = False
- with self.assertRaises(config.GitlabConfigMissingError):
+ with pytest.raises(config.GitlabConfigMissingError):
config.GitlabConfigParser("test")
@mock.patch("os.path.exists")
@@ -98,14 +99,14 @@ class TestConfigParser(unittest.TestCase):
m_open.return_value = fd
path_exists.return_value = True
config.GitlabConfigParser("there")
- self.assertRaises(config.GitlabIDError, config.GitlabConfigParser)
+ with pytest.raises(config.GitlabIDError):
+ config.GitlabConfigParser()
fd = io.StringIO(valid_config)
fd.close = mock.Mock(return_value=None)
m_open.return_value = fd
- self.assertRaises(
- config.GitlabDataError, config.GitlabConfigParser, gitlab_id="not_there"
- )
+ with pytest.raises(config.GitlabDataError):
+ config.GitlabConfigParser(gitlab_id="not_there")
@mock.patch("os.path.exists")
@mock.patch("builtins.open")
@@ -117,15 +118,13 @@ class TestConfigParser(unittest.TestCase):
config.GitlabConfigParser("one")
config.GitlabConfigParser("one")
- self.assertRaises(
- config.GitlabDataError, config.GitlabConfigParser, gitlab_id="two"
- )
- self.assertRaises(
- config.GitlabDataError, config.GitlabConfigParser, gitlab_id="three"
- )
- with self.assertRaises(config.GitlabDataError) as emgr:
+ with pytest.raises(config.GitlabDataError):
+ config.GitlabConfigParser(gitlab_id="two")
+ with pytest.raises(config.GitlabDataError):
+ config.GitlabConfigParser(gitlab_id="three")
+ with pytest.raises(config.GitlabDataError) as emgr:
config.GitlabConfigParser("four")
- self.assertEqual("Unsupported per_page number: 200", emgr.exception.args[0])
+ assert "Unsupported per_page number: 200" == emgr.value.args[0]
@mock.patch("os.path.exists")
@mock.patch("builtins.open")
@@ -136,44 +135,44 @@ class TestConfigParser(unittest.TestCase):
path_exists.return_value = True
cp = config.GitlabConfigParser()
- self.assertEqual("one", cp.gitlab_id)
- self.assertEqual("http://one.url", cp.url)
- self.assertEqual("ABCDEF", cp.private_token)
- self.assertEqual(None, cp.oauth_token)
- self.assertEqual(2, cp.timeout)
- self.assertEqual(True, cp.ssl_verify)
- self.assertIsNone(cp.per_page)
+ assert "one" == cp.gitlab_id
+ assert "http://one.url" == cp.url
+ assert "ABCDEF" == cp.private_token
+ assert None == cp.oauth_token
+ assert 2 == cp.timeout
+ assert True == cp.ssl_verify
+ assert cp.per_page is None
fd = io.StringIO(valid_config)
fd.close = mock.Mock(return_value=None)
m_open.return_value = fd
cp = config.GitlabConfigParser(gitlab_id="two")
- self.assertEqual("two", cp.gitlab_id)
- self.assertEqual("https://two.url", cp.url)
- self.assertEqual("GHIJKL", cp.private_token)
- self.assertEqual(None, cp.oauth_token)
- self.assertEqual(10, cp.timeout)
- self.assertEqual(False, cp.ssl_verify)
+ assert "two" == cp.gitlab_id
+ assert "https://two.url" == cp.url
+ assert "GHIJKL" == cp.private_token
+ assert None == cp.oauth_token
+ assert 10 == cp.timeout
+ assert False == cp.ssl_verify
fd = io.StringIO(valid_config)
fd.close = mock.Mock(return_value=None)
m_open.return_value = fd
cp = config.GitlabConfigParser(gitlab_id="three")
- self.assertEqual("three", cp.gitlab_id)
- self.assertEqual("https://three.url", cp.url)
- self.assertEqual("MNOPQR", cp.private_token)
- self.assertEqual(None, cp.oauth_token)
- self.assertEqual(2, cp.timeout)
- self.assertEqual("/path/to/CA/bundle.crt", cp.ssl_verify)
- self.assertEqual(50, cp.per_page)
+ assert "three" == cp.gitlab_id
+ assert "https://three.url" == cp.url
+ assert "MNOPQR" == cp.private_token
+ assert None == cp.oauth_token
+ assert 2 == cp.timeout
+ assert "/path/to/CA/bundle.crt" == cp.ssl_verify
+ assert 50 == cp.per_page
fd = io.StringIO(valid_config)
fd.close = mock.Mock(return_value=None)
m_open.return_value = fd
cp = config.GitlabConfigParser(gitlab_id="four")
- self.assertEqual("four", cp.gitlab_id)
- self.assertEqual("https://four.url", cp.url)
- self.assertEqual(None, cp.private_token)
- self.assertEqual("STUV", cp.oauth_token)
- self.assertEqual(2, cp.timeout)
- self.assertEqual(True, cp.ssl_verify)
+ assert "four" == cp.gitlab_id
+ assert "https://four.url" == cp.url
+ assert None == cp.private_token
+ assert "STUV" == cp.oauth_token
+ assert 2 == cp.timeout
+ assert True == cp.ssl_verify
diff --git a/gitlab/tests/test_exceptions.py b/gitlab/tests/test_exceptions.py
index 1f00af0..57622c0 100644
--- a/gitlab/tests/test_exceptions.py
+++ b/gitlab/tests/test_exceptions.py
@@ -1,6 +1,7 @@
import unittest
from gitlab import exceptions
+import pytest
class TestExceptions(unittest.TestCase):
@@ -14,6 +15,6 @@ class TestExceptions(unittest.TestCase):
def raise_error_from_http_error():
raise exceptions.GitlabHttpError
- with self.assertRaises(TestError) as context:
+ with pytest.raises(TestError) as context:
raise_error_from_http_error()
- self.assertIsInstance(context.exception.__cause__, exceptions.GitlabHttpError)
+ assert isinstance(context.value.__cause__, exceptions.GitlabHttpError)
diff --git a/gitlab/tests/test_gitlab.py b/gitlab/tests/test_gitlab.py
index 6fc551c..59139e4 100644
--- a/gitlab/tests/test_gitlab.py
+++ b/gitlab/tests/test_gitlab.py
@@ -30,6 +30,7 @@ import requests
import gitlab
from gitlab import * # noqa
from gitlab.v4.objects import * # noqa
+import pytest
valid_config = b"""[global]
@@ -45,17 +46,17 @@ private_token = ABCDEF
class TestSanitize(unittest.TestCase):
def test_do_nothing(self):
- self.assertEqual(1, gitlab._sanitize(1))
- self.assertEqual(1.5, gitlab._sanitize(1.5))
- self.assertEqual("foo", gitlab._sanitize("foo"))
+ assert 1 == gitlab._sanitize(1)
+ assert 1.5 == gitlab._sanitize(1.5)
+ assert "foo" == gitlab._sanitize("foo")
def test_slash(self):
- self.assertEqual("foo%2Fbar", gitlab._sanitize("foo/bar"))
+ assert "foo%2Fbar" == gitlab._sanitize("foo/bar")
def test_dict(self):
source = {"url": "foo/bar", "id": 1}
expected = {"url": "foo%2Fbar", "id": 1}
- self.assertEqual(expected, gitlab._sanitize(source))
+ assert expected == gitlab._sanitize(source)
class TestGitlabList(unittest.TestCase):
@@ -102,22 +103,20 @@ class TestGitlabList(unittest.TestCase):
with HTTMock(resp_1):
obj = self.gl.http_list("/tests", as_list=False)
- self.assertEqual(len(obj), 2)
- self.assertEqual(
- obj._next_url, "http://localhost/api/v4/tests?per_page=1&page=2"
- )
- self.assertEqual(obj.current_page, 1)
- self.assertEqual(obj.prev_page, None)
- self.assertEqual(obj.next_page, 2)
- self.assertEqual(obj.per_page, 1)
- self.assertEqual(obj.total_pages, 2)
- self.assertEqual(obj.total, 2)
+ assert len(obj) == 2
+ assert obj._next_url == "http://localhost/api/v4/tests?per_page=1&page=2"
+ assert obj.current_page == 1
+ assert obj.prev_page == None
+ assert obj.next_page == 2
+ assert obj.per_page == 1
+ assert obj.total_pages == 2
+ assert obj.total == 2
with HTTMock(resp_2):
l = list(obj)
- self.assertEqual(len(l), 2)
- self.assertEqual(l[0]["a"], "b")
- self.assertEqual(l[1]["c"], "d")
+ assert len(l) == 2
+ assert l[0]["a"] == "b"
+ assert l[1]["c"] == "d"
def test_all_omitted_when_as_list(self):
@urlmatch(scheme="http", netloc="localhost", path="/api/v4/tests", method="get")
@@ -135,7 +134,7 @@ class TestGitlabList(unittest.TestCase):
with HTTMock(resp):
result = self.gl.http_list("/tests", as_list=False, all=True)
- self.assertIsInstance(result, GitlabList)
+ assert isinstance(result, GitlabList)
class TestGitlabHttpMethods(unittest.TestCase):
@@ -146,11 +145,11 @@ class TestGitlabHttpMethods(unittest.TestCase):
def test_build_url(self):
r = self.gl._build_url("http://localhost/api/v4")
- self.assertEqual(r, "http://localhost/api/v4")
+ assert r == "http://localhost/api/v4"
r = self.gl._build_url("https://localhost/api/v4")
- self.assertEqual(r, "https://localhost/api/v4")
+ assert r == "https://localhost/api/v4"
r = self.gl._build_url("/projects")
- self.assertEqual(r, "http://localhost/api/v4/projects")
+ assert r == "http://localhost/api/v4/projects"
def test_http_request(self):
@urlmatch(
@@ -164,7 +163,7 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
http_r = self.gl.http_request("get", "/projects")
http_r.json()
- self.assertEqual(http_r.status_code, 200)
+ assert http_r.status_code == 200
def test_http_request_404(self):
@urlmatch(
@@ -175,9 +174,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(
- GitlabHttpError, self.gl.http_request, "get", "/not_there"
- )
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_request("get", "/not_there")
def test_get_request(self):
@urlmatch(
@@ -190,8 +188,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_get("/projects")
- self.assertIsInstance(result, dict)
- self.assertEqual(result["name"], "project1")
+ assert isinstance(result, dict)
+ assert result["name"] == "project1"
def test_get_request_raw(self):
@urlmatch(
@@ -204,7 +202,7 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_get("/projects")
- self.assertEqual(result.content.decode("utf-8"), "content")
+ assert result.content.decode("utf-8") == "content"
def test_get_request_404(self):
@urlmatch(
@@ -215,7 +213,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabHttpError, self.gl.http_get, "/not_there")
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_get("/not_there")
def test_get_request_invalid_data(self):
@urlmatch(
@@ -227,7 +226,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(200, content, headers, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabParsingError, self.gl.http_get, "/projects")
+ with pytest.raises(GitlabParsingError):
+ self.gl.http_get("/projects")
def test_list_request(self):
@urlmatch(
@@ -240,18 +240,18 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_list("/projects", as_list=True)
- self.assertIsInstance(result, list)
- self.assertEqual(len(result), 1)
+ assert isinstance(result, list)
+ assert len(result) == 1
with HTTMock(resp_cont):
result = self.gl.http_list("/projects", as_list=False)
- self.assertIsInstance(result, GitlabList)
- self.assertEqual(len(result), 1)
+ assert isinstance(result, GitlabList)
+ assert len(result) == 1
with HTTMock(resp_cont):
result = self.gl.http_list("/projects", all=True)
- self.assertIsInstance(result, list)
- self.assertEqual(len(result), 1)
+ assert isinstance(result, list)
+ assert len(result) == 1
def test_list_request_404(self):
@urlmatch(
@@ -262,7 +262,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabHttpError, self.gl.http_list, "/not_there")
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_list("/not_there")
def test_list_request_invalid_data(self):
@urlmatch(
@@ -274,7 +275,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(200, content, headers, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabParsingError, self.gl.http_list, "/projects")
+ with pytest.raises(GitlabParsingError):
+ self.gl.http_list("/projects")
def test_post_request(self):
@urlmatch(
@@ -287,8 +289,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_post("/projects")
- self.assertIsInstance(result, dict)
- self.assertEqual(result["name"], "project1")
+ assert isinstance(result, dict)
+ assert result["name"] == "project1"
def test_post_request_404(self):
@urlmatch(
@@ -299,7 +301,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabHttpError, self.gl.http_post, "/not_there")
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_post("/not_there")
def test_post_request_invalid_data(self):
@urlmatch(
@@ -311,7 +314,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(200, content, headers, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabParsingError, self.gl.http_post, "/projects")
+ with pytest.raises(GitlabParsingError):
+ self.gl.http_post("/projects")
def test_put_request(self):
@urlmatch(
@@ -324,8 +328,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_put("/projects")
- self.assertIsInstance(result, dict)
- self.assertEqual(result["name"], "project1")
+ assert isinstance(result, dict)
+ assert result["name"] == "project1"
def test_put_request_404(self):
@urlmatch(
@@ -336,7 +340,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabHttpError, self.gl.http_put, "/not_there")
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_put("/not_there")
def test_put_request_invalid_data(self):
@urlmatch(
@@ -348,7 +353,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(200, content, headers, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabParsingError, self.gl.http_put, "/projects")
+ with pytest.raises(GitlabParsingError):
+ self.gl.http_put("/projects")
def test_delete_request(self):
@urlmatch(
@@ -361,8 +367,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
with HTTMock(resp_cont):
result = self.gl.http_delete("/projects")
- self.assertIsInstance(result, requests.Response)
- self.assertEqual(result.json(), True)
+ assert isinstance(result, requests.Response)
+ assert result.json() == True
def test_delete_request_404(self):
@urlmatch(
@@ -373,7 +379,8 @@ class TestGitlabHttpMethods(unittest.TestCase):
return response(404, content, {}, None, 5, request)
with HTTMock(resp_cont):
- self.assertRaises(GitlabHttpError, self.gl.http_delete, "/not_there")
+ with pytest.raises(GitlabHttpError):
+ self.gl.http_delete("/not_there")
class TestGitlabStripBaseUrl(unittest.TestCase):
@@ -383,81 +390,77 @@ class TestGitlabStripBaseUrl(unittest.TestCase):
)
def test_strip_base_url(self):
- self.assertEqual(self.gl.url, "http://localhost")
+ assert self.gl.url == "http://localhost"
def test_strip_api_url(self):
- self.assertEqual(self.gl.api_url, "http://localhost/api/v4")
+ assert self.gl.api_url == "http://localhost/api/v4"
def test_build_url(self):
r = self.gl._build_url("/projects")
- self.assertEqual(r, "http://localhost/api/v4/projects")
+ assert r == "http://localhost/api/v4/projects"
class TestGitlabAuth(unittest.TestCase):
def test_invalid_auth_args(self):
- self.assertRaises(
- ValueError,
- Gitlab,
- "http://localhost",
- api_version="4",
- private_token="private_token",
- oauth_token="bearer",
- )
- self.assertRaises(
- ValueError,
- Gitlab,
- "http://localhost",
- api_version="4",
- oauth_token="bearer",
- http_username="foo",
- http_password="bar",
- )
- self.assertRaises(
- ValueError,
- Gitlab,
- "http://localhost",
- api_version="4",
- private_token="private_token",
- http_password="bar",
- )
- self.assertRaises(
- ValueError,
- Gitlab,
- "http://localhost",
- api_version="4",
- private_token="private_token",
- http_username="foo",
- )
+ with pytest.raises(ValueError):
+ Gitlab(
+ "http://localhost",
+ api_version="4",
+ private_token="private_token",
+ oauth_token="bearer",
+ )
+ with pytest.raises(ValueError):
+ Gitlab(
+ "http://localhost",
+ api_version="4",
+ oauth_token="bearer",
+ http_username="foo",
+ http_password="bar",
+ )
+ with pytest.raises(ValueError):
+ Gitlab(
+ "http://localhost",
+ api_version="4",
+ private_token="private_token",
+ http_password="bar",
+ )
+ with pytest.raises(ValueError):
+ Gitlab(
+ "http://localhost",
+ api_version="4",
+ private_token="private_token",
+ http_username="foo",
+ )
def test_private_token_auth(self):
gl = Gitlab("http://localhost", private_token="private_token", api_version="4")
- self.assertEqual(gl.private_token, "private_token")
- self.assertEqual(gl.oauth_token, None)
- self.assertEqual(gl.job_token, None)
- self.assertEqual(gl._http_auth, None)
- self.assertNotIn("Authorization", gl.headers)
- self.assertEqual(gl.headers["PRIVATE-TOKEN"], "private_token")
- self.assertNotIn("JOB-TOKEN", gl.headers)
+ assert gl.private_token == "private_token"
+ assert gl.oauth_token == None
+ assert gl.job_token == None
+ assert gl._http_auth == None
+ assert "Authorization" not in gl.headers
+ assert gl.headers["PRIVATE-TOKEN"] == "private_token"
+ assert "JOB-TOKEN" not in gl.headers
def test_oauth_token_auth(self):
gl = Gitlab("http://localhost", oauth_token="oauth_token", api_version="4")
- self.assertEqual(gl.private_token, None)
- self.assertEqual(gl.oauth_token, "oauth_token")
- self.assertEqual(gl.job_token, None)
- self.assertEqual(gl._http_auth, None)
- self.assertEqual(gl.headers["Authorization"], "Bearer oauth_token")
- self.assertNotIn("PRIVATE-TOKEN", gl.headers)
- self.assertNotIn("JOB-TOKEN", gl.headers)
+ assert gl.private_token == None
+ assert gl.oauth_token == "oauth_token"
+ assert gl.job_token == None
+ assert gl._http_auth == None
+ assert gl.headers["Authorization"] == "Bearer oauth_token"
+ assert "PRIVATE-TOKEN" not in gl.headers
+ assert "JOB-TOKEN" not in gl.headers
def test_job_token_auth(self):
gl = Gitlab("http://localhost", job_token="CI_JOB_TOKEN", api_version="4")
- self.assertEqual(gl.private_token, None)
- self.assertEqual(gl.oauth_token, None)
- self.assertEqual(gl.job_token, "CI_JOB_TOKEN")
- self.assertEqual(gl._http_auth, None)
- self.assertNotIn("Authorization", gl.headers)
- self.assertNotIn("PRIVATE-TOKEN", gl.headers)
- self.assertEqual(gl.headers["JOB-TOKEN"], "CI_JOB_TOKEN")
+ assert gl.private_token == None
+ assert gl.oauth_token == None
+ assert gl.job_token == "CI_JOB_TOKEN"
+ assert gl._http_auth == None
+ assert "Authorization" not in gl.headers
+ assert "PRIVATE-TOKEN" not in gl.headers
+ assert gl.headers["JOB-TOKEN"] == "CI_JOB_TOKEN"
def test_http_auth(self):
gl = Gitlab(
@@ -467,12 +470,12 @@ class TestGitlabAuth(unittest.TestCase):
http_password="bar",
api_version="4",
)
- self.assertEqual(gl.private_token, "private_token")
- self.assertEqual(gl.oauth_token, None)
- self.assertEqual(gl.job_token, None)
- self.assertIsInstance(gl._http_auth, requests.auth.HTTPBasicAuth)
- self.assertEqual(gl.headers["PRIVATE-TOKEN"], "private_token")
- self.assertNotIn("Authorization", gl.headers)
+ assert gl.private_token == "private_token"
+ assert gl.oauth_token == None
+ assert gl.job_token == None
+ assert isinstance(gl._http_auth, requests.auth.HTTPBasicAuth)
+ assert gl.headers["PRIVATE-TOKEN"] == "private_token"
+ assert "Authorization" not in gl.headers
class TestGitlab(unittest.TestCase):
@@ -488,9 +491,9 @@ class TestGitlab(unittest.TestCase):
original_gl_objects = self.gl._objects
pickled = pickle.dumps(self.gl)
unpickled = pickle.loads(pickled)
- self.assertIsInstance(unpickled, Gitlab)
- self.assertTrue(hasattr(unpickled, "_objects"))
- self.assertEqual(unpickled._objects, original_gl_objects)
+ assert isinstance(unpickled, Gitlab)
+ assert hasattr(unpickled, "_objects")
+ assert unpickled._objects == original_gl_objects
def test_token_auth(self, callback=None):
name = "username"
@@ -506,9 +509,9 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_cont):
self.gl.auth()
- self.assertEqual(self.gl.user.username, name)
- self.assertEqual(self.gl.user.id, id_)
- self.assertIsInstance(self.gl.user, CurrentUser)
+ assert self.gl.user.username == name
+ assert self.gl.user.id == id_
+ assert isinstance(self.gl.user, CurrentUser)
def test_hooks(self):
@urlmatch(
@@ -521,9 +524,9 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_hook):
data = self.gl.hooks.get(1)
- self.assertIsInstance(data, Hook)
- self.assertEqual(data.url, "testurl")
- self.assertEqual(data.id, 1)
+ assert isinstance(data, Hook)
+ assert data.url == "testurl"
+ assert data.id == 1
def test_projects(self):
@urlmatch(
@@ -536,9 +539,9 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_project):
data = self.gl.projects.get(1)
- self.assertIsInstance(data, Project)
- self.assertEqual(data.name, "name")
- self.assertEqual(data.id, 1)
+ assert isinstance(data, Project)
+ assert data.name == "name"
+ assert data.id == 1
def test_project_environments(self):
@urlmatch(
@@ -565,10 +568,10 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_project, resp_get_environment):
project = self.gl.projects.get(1)
environment = project.environments.get(1)
- self.assertIsInstance(environment, ProjectEnvironment)
- self.assertEqual(environment.id, 1)
- self.assertEqual(environment.last_deployment, "sometime")
- self.assertEqual(environment.name, "environment_name")
+ assert isinstance(environment, ProjectEnvironment)
+ assert environment.id == 1
+ assert environment.last_deployment == "sometime"
+ assert environment.name == "environment_name"
def test_project_additional_statistics(self):
@urlmatch(
@@ -595,8 +598,8 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_project, resp_get_environment):
project = self.gl.projects.get(1)
statistics = project.additionalstatistics.get()
- self.assertIsInstance(statistics, ProjectAdditionalStatistics)
- self.assertEqual(statistics.fetches["total"], 50)
+ assert isinstance(statistics, ProjectAdditionalStatistics)
+ assert statistics.fetches["total"] == 50
def test_project_issues_statistics(self):
@urlmatch(
@@ -623,8 +626,8 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_project, resp_get_environment):
project = self.gl.projects.get(1)
statistics = project.issuesstatistics.get()
- self.assertIsInstance(statistics, ProjectIssuesStatistics)
- self.assertEqual(statistics.statistics["counts"]["all"], 20)
+ assert isinstance(statistics, ProjectIssuesStatistics)
+ assert statistics.statistics["counts"]["all"] == 20
def test_issues(self):
@urlmatch(
@@ -638,8 +641,8 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_issue):
data = self.gl.issues.list()
- self.assertEqual(data[1].id, 2)
- self.assertEqual(data[1].name, "other_name")
+ assert data[1].id == 2
+ assert data[1].name == "other_name"
@urlmatch(scheme="http", netloc="localhost", path="/api/v4/users/1", method="get")
def resp_get_user(self, url, request):
@@ -654,9 +657,9 @@ class TestGitlab(unittest.TestCase):
def test_users(self):
with HTTMock(self.resp_get_user):
user = self.gl.users.get(1)
- self.assertIsInstance(user, User)
- self.assertEqual(user.name, "name")
- self.assertEqual(user.id, 1)
+ assert isinstance(user, User)
+ assert user.name == "name"
+ assert user.id == 1
def test_user_memberships(self):
@urlmatch(
@@ -687,8 +690,8 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_user_memberships):
user = self.gl.users.get(1, lazy=True)
memberships = user.memberships.list()
- self.assertIsInstance(memberships[0], UserMembership)
- self.assertEqual(memberships[0].source_type, "Project")
+ assert isinstance(memberships[0], UserMembership)
+ assert memberships[0].source_type == "Project"
def test_user_status(self):
@urlmatch(
@@ -707,9 +710,9 @@ class TestGitlab(unittest.TestCase):
user = self.gl.users.get(1)
with HTTMock(resp_get_user_status):
status = user.status.get()
- self.assertIsInstance(status, UserStatus)
- self.assertEqual(status.message, "test")
- self.assertEqual(status.emoji, "thumbsup")
+ assert isinstance(status, UserStatus)
+ assert status.message == "test"
+ assert status.emoji == "thumbsup"
def test_todo(self):
with open(os.path.dirname(__file__) + "/data/todo.json", "r") as json_file:
@@ -736,10 +739,10 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_todo):
todo = self.gl.todos.list()[0]
- self.assertIsInstance(todo, Todo)
- self.assertEqual(todo.id, 102)
- self.assertEqual(todo.target_type, "MergeRequest")
- self.assertEqual(todo.target["assignee"]["username"], "root")
+ assert isinstance(todo, Todo)
+ assert todo.id == 102
+ assert todo.target_type == "MergeRequest"
+ assert todo.target["assignee"]["username"] == "root"
with HTTMock(resp_mark_as_done):
todo.mark_as_done()
@@ -791,15 +794,15 @@ class TestGitlab(unittest.TestCase):
"status": "created",
}
)
- self.assertEqual(deployment.id, 42)
- self.assertEqual(deployment.status, "success")
- self.assertEqual(deployment.ref, "master")
+ assert deployment.id == 42
+ assert deployment.status == "success"
+ assert deployment.ref == "master"
with HTTMock(resp_deployment_update):
json_content["status"] = "failed"
deployment.status = "failed"
deployment.save()
- self.assertEqual(deployment.status, "failed")
+ assert deployment.status == "failed"
def test_user_activate_deactivate(self):
@urlmatch(
@@ -862,9 +865,9 @@ class TestGitlab(unittest.TestCase):
with HTTMock(resp_get_project):
project = self.gl.projects.get(1)
- self.assertIsInstance(project, Project)
- self.assertEqual(project.name, "name")
- self.assertEqual(project.id, 1)
+ assert isinstance(project, Project)
+ assert project.name == "name"
+ assert project.id == 1
with HTTMock(resp_update_submodule):
ret = project.update_submodule(
submodule="foo/bar",
@@ -872,9 +875,9 @@ class TestGitlab(unittest.TestCase):
commit_sha="4c3674f66071e30b3311dac9b9ccc90502a72664",
commit_message="Message",
)
- self.assertIsInstance(ret, dict)
- self.assertEqual(ret["message"], "Message")
- self.assertEqual(ret["id"], "ed899a2f4b50b4370feeea94676502b42383c746")
+ assert isinstance(ret, dict)
+ assert ret["message"] == "Message"
+ assert ret["id"] == "ed899a2f4b50b4370feeea94676502b42383c746"
def test_applications(self):
content = '{"name": "test_app", "redirect_uri": "http://localhost:8080", "scopes": ["api", "email"]}'
@@ -899,9 +902,9 @@ class TestGitlab(unittest.TestCase):
"confidential": False,
}
)
- self.assertEqual(application.name, "test_app")
- self.assertEqual(application.redirect_uri, "http://localhost:8080")
- self.assertEqual(application.scopes, ["api", "email"])
+ assert application.name == "test_app"
+ assert application.redirect_uri == "http://localhost:8080"
+ assert application.scopes == ["api", "email"]
def test_deploy_tokens(self):
@urlmatch(
@@ -931,11 +934,11 @@ class TestGitlab(unittest.TestCase):
"scopes": ["read_repository"],
}
)
- self.assertIsInstance(deploy_token, ProjectDeployToken)
- self.assertEqual(deploy_token.id, 1),
- self.assertEqual(deploy_token.expires_at, "2022-01-01T00:00:00.000Z"),
- self.assertEqual(deploy_token.username, "custom-user")
- self.assertEqual(deploy_token.scopes, ["read_repository"])
+ assert isinstance(deploy_token, ProjectDeployToken)
+ assert deploy_token.id == 1
+ assert deploy_token.expires_at == "2022-01-01T00:00:00.000Z"
+ assert deploy_token.username == "custom-user"
+ assert deploy_token.scopes == ["read_repository"]
def _default_config(self):
fd, temp_path = tempfile.mkstemp()
@@ -954,5 +957,5 @@ class TestGitlab(unittest.TestCase):
config_path = self._default_config()
gl = MyGitlab.from_config("one", [config_path])
- self.assertIsInstance(gl, MyGitlab)
+ assert isinstance(gl, MyGitlab)
os.unlink(config_path)
diff --git a/gitlab/tests/test_mixins.py b/gitlab/tests/test_mixins.py
index 749c0d2..e8613f2 100644
--- a/gitlab/tests/test_mixins.py
+++ b/gitlab/tests/test_mixins.py
@@ -25,6 +25,7 @@ from httmock import urlmatch # noqa
from gitlab import * # noqa
from gitlab.base import * # noqa
from gitlab.mixins import * # noqa
+import pytest
class TestObjectMixinsAttributes(unittest.TestCase):
@@ -33,47 +34,47 @@ class TestObjectMixinsAttributes(unittest.TestCase):
pass
obj = O()
- self.assertTrue(hasattr(obj, "approve"))
+ assert hasattr(obj, "approve")
def test_subscribable_mixin(self):
class O(SubscribableMixin):
pass
obj = O()
- self.assertTrue(hasattr(obj, "subscribe"))
- self.assertTrue(hasattr(obj, "unsubscribe"))
+ assert hasattr(obj, "subscribe")
+ assert hasattr(obj, "unsubscribe")
def test_todo_mixin(self):
class O(TodoMixin):
pass
obj = O()
- self.assertTrue(hasattr(obj, "todo"))
+ assert hasattr(obj, "todo")
def test_time_tracking_mixin(self):
class O(TimeTrackingMixin):
pass
obj = O()
- self.assertTrue(hasattr(obj, "time_stats"))
- self.assertTrue(hasattr(obj, "time_estimate"))
- self.assertTrue(hasattr(obj, "reset_time_estimate"))
- self.assertTrue(hasattr(obj, "add_spent_time"))
- self.assertTrue(hasattr(obj, "reset_spent_time"))
+ assert hasattr(obj, "time_stats")
+ assert hasattr(obj, "time_estimate")
+ assert hasattr(obj, "reset_time_estimate")
+ assert hasattr(obj, "add_spent_time")
+ assert hasattr(obj, "reset_spent_time")
def test_set_mixin(self):
class O(SetMixin):
pass
obj = O()
- self.assertTrue(hasattr(obj, "set"))
+ assert hasattr(obj, "set")
def test_user_agent_detail_mixin(self):
class O(UserAgentDetailMixin):
pass
obj = O()
- self.assertTrue(hasattr(obj, "user_agent_detail"))
+ assert hasattr(obj, "user_agent_detail")
class TestMetaMixins(unittest.TestCase):
@@ -82,45 +83,45 @@ class TestMetaMixins(unittest.TestCase):
pass
obj = M()
- self.assertTrue(hasattr(obj, "list"))
- self.assertTrue(hasattr(obj, "get"))
- self.assertFalse(hasattr(obj, "create"))
- self.assertFalse(hasattr(obj, "update"))
- self.assertFalse(hasattr(obj, "delete"))
- self.assertIsInstance(obj, ListMixin)
- self.assertIsInstance(obj, GetMixin)
+ assert hasattr(obj, "list")
+ assert hasattr(obj, "get")
+ assert not hasattr(obj, "create")
+ assert not hasattr(obj, "update")
+ assert not hasattr(obj, "delete")
+ assert isinstance(obj, ListMixin)
+ assert isinstance(obj, GetMixin)
def test_crud_mixin(self):
class M(CRUDMixin):
pass
obj = M()
- self.assertTrue(hasattr(obj, "get"))
- self.assertTrue(hasattr(obj, "list"))
- self.assertTrue(hasattr(obj, "create"))
- self.assertTrue(hasattr(obj, "update"))
- self.assertTrue(hasattr(obj, "delete"))
- self.assertIsInstance(obj, ListMixin)
- self.assertIsInstance(obj, GetMixin)
- self.assertIsInstance(obj, CreateMixin)
- self.assertIsInstance(obj, UpdateMixin)
- self.assertIsInstance(obj, DeleteMixin)
+ assert hasattr(obj, "get")
+ assert hasattr(obj, "list")
+ assert hasattr(obj, "create")
+ assert hasattr(obj, "update")
+ assert hasattr(obj, "delete")
+ assert isinstance(obj, ListMixin)
+ assert isinstance(obj, GetMixin)
+ assert isinstance(obj, CreateMixin)
+ assert isinstance(obj, UpdateMixin)
+ assert isinstance(obj, DeleteMixin)
def test_no_update_mixin(self):
class M(NoUpdateMixin):
pass
obj = M()
- self.assertTrue(hasattr(obj, "get"))
- self.assertTrue(hasattr(obj, "list"))
- self.assertTrue(hasattr(obj, "create"))
- self.assertFalse(hasattr(obj, "update"))
- self.assertTrue(hasattr(obj, "delete"))
- self.assertIsInstance(obj, ListMixin)
- self.assertIsInstance(obj, GetMixin)
- self.assertIsInstance(obj, CreateMixin)
- self.assertNotIsInstance(obj, UpdateMixin)
- self.assertIsInstance(obj, DeleteMixin)
+ assert hasattr(obj, "get")
+ assert hasattr(obj, "list")
+ assert hasattr(obj, "create")
+ assert not hasattr(obj, "update")
+ assert hasattr(obj, "delete")
+ assert isinstance(obj, ListMixin)
+ assert isinstance(obj, GetMixin)
+ assert isinstance(obj, CreateMixin)
+ assert not isinstance(obj, UpdateMixin)
+ assert isinstance(obj, DeleteMixin)
class FakeObject(base.RESTObject):
@@ -153,9 +154,9 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj = mgr.get(42)
- self.assertIsInstance(obj, FakeObject)
- self.assertEqual(obj.foo, "bar")
- self.assertEqual(obj.id, 42)
+ assert isinstance(obj, FakeObject)
+ assert obj.foo == "bar"
+ assert obj.id == 42
def test_refresh_mixin(self):
class O(RefreshMixin, FakeObject):
@@ -173,9 +174,9 @@ class TestMixinMethods(unittest.TestCase):
mgr = FakeManager(self.gl)
obj = O(mgr, {"id": 42})
res = obj.refresh()
- self.assertIsNone(res)
- self.assertEqual(obj.foo, "bar")
- self.assertEqual(obj.id, 42)
+ assert res is None
+ assert obj.foo == "bar"
+ assert obj.id == 42
def test_get_without_id_mixin(self):
class M(GetWithoutIdMixin, FakeManager):
@@ -190,9 +191,9 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj = mgr.get()
- self.assertIsInstance(obj, FakeObject)
- self.assertEqual(obj.foo, "bar")
- self.assertFalse(hasattr(obj, "id"))
+ assert isinstance(obj, FakeObject)
+ assert obj.foo == "bar"
+ assert not hasattr(obj, "id")
def test_list_mixin(self):
class M(ListMixin, FakeManager):
@@ -208,18 +209,18 @@ class TestMixinMethods(unittest.TestCase):
# test RESTObjectList
mgr = M(self.gl)
obj_list = mgr.list(as_list=False)
- self.assertIsInstance(obj_list, base.RESTObjectList)
+ assert isinstance(obj_list, base.RESTObjectList)
for obj in obj_list:
- self.assertIsInstance(obj, FakeObject)
- self.assertIn(obj.id, (42, 43))
+ assert isinstance(obj, FakeObject)
+ assert obj.id in (42, 43)
# test list()
obj_list = mgr.list(all=True)
- self.assertIsInstance(obj_list, list)
- self.assertEqual(obj_list[0].id, 42)
- self.assertEqual(obj_list[1].id, 43)
- self.assertIsInstance(obj_list[0], FakeObject)
- self.assertEqual(len(obj_list), 2)
+ assert isinstance(obj_list, list)
+ assert obj_list[0].id == 42
+ assert obj_list[1].id == 43
+ assert isinstance(obj_list[0], FakeObject)
+ assert len(obj_list) == 2
def test_list_other_url(self):
class M(ListMixin, FakeManager):
@@ -236,11 +237,12 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj_list = mgr.list(path="/others", as_list=False)
- self.assertIsInstance(obj_list, base.RESTObjectList)
+ assert isinstance(obj_list, base.RESTObjectList)
obj = obj_list.next()
- self.assertEqual(obj.id, 42)
- self.assertEqual(obj.foo, "bar")
- self.assertRaises(StopIteration, obj_list.next)
+ assert obj.id == 42
+ assert obj.foo == "bar"
+ with pytest.raises(StopIteration):
+ obj_list.next()
def test_create_mixin_get_attrs(self):
class M1(CreateMixin, FakeManager):
@@ -252,15 +254,15 @@ class TestMixinMethods(unittest.TestCase):
mgr = M1(self.gl)
required, optional = mgr.get_create_attrs()
- self.assertEqual(len(required), 0)
- self.assertEqual(len(optional), 0)
+ assert len(required) == 0
+ assert len(optional) == 0
mgr = M2(self.gl)
required, optional = mgr.get_create_attrs()
- self.assertIn("foo", required)
- self.assertIn("bar", optional)
- self.assertIn("baz", optional)
- self.assertNotIn("bam", optional)
+ assert "foo" in required
+ assert "bar" in optional
+ assert "baz" in optional
+ assert "bam" not in optional
def test_create_mixin_missing_attrs(self):
class M(CreateMixin, FakeManager):
@@ -271,9 +273,9 @@ class TestMixinMethods(unittest.TestCase):
mgr._check_missing_create_attrs(data)
data = {"baz": "blah"}
- with self.assertRaises(AttributeError) as error:
+ with pytest.raises(AttributeError) as error:
mgr._check_missing_create_attrs(data)
- self.assertIn("foo", str(error.exception))
+ assert "foo" in str(error.value)
def test_create_mixin(self):
class M(CreateMixin, FakeManager):
@@ -291,9 +293,9 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj = mgr.create({"foo": "bar"})
- self.assertIsInstance(obj, FakeObject)
- self.assertEqual(obj.id, 42)
- self.assertEqual(obj.foo, "bar")
+ assert isinstance(obj, FakeObject)
+ assert obj.id == 42
+ assert obj.foo == "bar"
def test_create_mixin_custom_path(self):
class M(CreateMixin, FakeManager):
@@ -311,9 +313,9 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj = mgr.create({"foo": "bar"}, path="/others")
- self.assertIsInstance(obj, FakeObject)
- self.assertEqual(obj.id, 42)
- self.assertEqual(obj.foo, "bar")
+ assert isinstance(obj, FakeObject)
+ assert obj.id == 42
+ assert obj.foo == "bar"
def test_update_mixin_get_attrs(self):
class M1(UpdateMixin, FakeManager):
@@ -325,15 +327,15 @@ class TestMixinMethods(unittest.TestCase):
mgr = M1(self.gl)
required, optional = mgr.get_update_attrs()
- self.assertEqual(len(required), 0)
- self.assertEqual(len(optional), 0)
+ assert len(required) == 0
+ assert len(optional) == 0
mgr = M2(self.gl)
required, optional = mgr.get_update_attrs()
- self.assertIn("foo", required)
- self.assertIn("bam", optional)
- self.assertNotIn("bar", optional)
- self.assertNotIn("baz", optional)
+ assert "foo" in required
+ assert "bam" in optional
+ assert "bar" not in optional
+ assert "baz" not in optional
def test_update_mixin_missing_attrs(self):
class M(UpdateMixin, FakeManager):
@@ -344,9 +346,9 @@ class TestMixinMethods(unittest.TestCase):
mgr._check_missing_update_attrs(data)
data = {"baz": "blah"}
- with self.assertRaises(AttributeError) as error:
+ with pytest.raises(AttributeError) as error:
mgr._check_missing_update_attrs(data)
- self.assertIn("foo", str(error.exception))
+ assert "foo" in str(error.value)
def test_update_mixin(self):
class M(UpdateMixin, FakeManager):
@@ -364,9 +366,9 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
server_data = mgr.update(42, {"foo": "baz"})
- self.assertIsInstance(server_data, dict)
- self.assertEqual(server_data["id"], 42)
- self.assertEqual(server_data["foo"], "baz")
+ assert isinstance(server_data, dict)
+ assert server_data["id"] == 42
+ assert server_data["foo"] == "baz"
def test_update_mixin_no_id(self):
class M(UpdateMixin, FakeManager):
@@ -382,8 +384,8 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
server_data = mgr.update(new_data={"foo": "baz"})
- self.assertIsInstance(server_data, dict)
- self.assertEqual(server_data["foo"], "baz")
+ assert isinstance(server_data, dict)
+ assert server_data["foo"] == "baz"
def test_delete_mixin(self):
class M(DeleteMixin, FakeManager):
@@ -421,8 +423,8 @@ class TestMixinMethods(unittest.TestCase):
obj = O(mgr, {"id": 42, "foo": "bar"})
obj.foo = "baz"
obj.save()
- self.assertEqual(obj._attrs["foo"], "baz")
- self.assertDictEqual(obj._updated_attrs, {})
+ assert obj._attrs["foo"] == "baz"
+ assert obj._updated_attrs == {}
def test_set_mixin(self):
class M(SetMixin, FakeManager):
@@ -439,6 +441,6 @@ class TestMixinMethods(unittest.TestCase):
with HTTMock(resp_cont):
mgr = M(self.gl)
obj = mgr.set("foo", "bar")
- self.assertIsInstance(obj, FakeObject)
- self.assertEqual(obj.key, "foo")
- self.assertEqual(obj.value, "bar")
+ assert isinstance(obj, FakeObject)
+ assert obj.key == "foo"
+ assert obj.value == "bar"
diff --git a/gitlab/tests/test_types.py b/gitlab/tests/test_types.py
index 3613383..8471bdf 100644
--- a/gitlab/tests/test_types.py
+++ b/gitlab/tests/test_types.py
@@ -23,49 +23,49 @@ from gitlab import types
class TestGitlabAttribute(unittest.TestCase):
def test_all(self):
o = types.GitlabAttribute("whatever")
- self.assertEqual("whatever", o.get())
+ assert "whatever" == o.get()
o.set_from_cli("whatever2")
- self.assertEqual("whatever2", o.get())
+ assert "whatever2" == o.get()
- self.assertEqual("whatever2", o.get_for_api())
+ assert "whatever2" == o.get_for_api()
o = types.GitlabAttribute()
- self.assertEqual(None, o._value)
+ assert None == o._value
class TestListAttribute(unittest.TestCase):
def test_list_input(self):
o = types.ListAttribute()
o.set_from_cli("foo,bar,baz")
- self.assertEqual(["foo", "bar", "baz"], o.get())
+ assert ["foo", "bar", "baz"] == o.get()
o.set_from_cli("foo")
- self.assertEqual(["foo"], o.get())
+ assert ["foo"] == o.get()
def test_empty_input(self):
o = types.ListAttribute()
o.set_from_cli("")
- self.assertEqual([], o.get())
+ assert [] == o.get()
o.set_from_cli(" ")
- self.assertEqual([], o.get())
+ assert [] == o.get()
def test_get_for_api_from_cli(self):
o = types.ListAttribute()
o.set_from_cli("foo,bar,baz")
- self.assertEqual("foo,bar,baz", o.get_for_api())
+ assert "foo,bar,baz" == o.get_for_api()
def test_get_for_api_from_list(self):
o = types.ListAttribute(["foo", "bar", "baz"])
- self.assertEqual("foo,bar,baz", o.get_for_api())
+ assert "foo,bar,baz" == o.get_for_api()
def test_get_for_api_does_not_split_string(self):
o = types.ListAttribute("foo")
- self.assertEqual("foo", o.get_for_api())
+ assert "foo" == o.get_for_api()
class TestLowercaseStringAttribute(unittest.TestCase):
def test_get_for_api(self):
o = types.LowercaseStringAttribute("FOO")
- self.assertEqual("foo", o.get_for_api())
+ assert "foo" == o.get_for_api()
diff --git a/gitlab/tests/test_utils.py b/gitlab/tests/test_utils.py
index b57deda..7ebd006 100644
--- a/gitlab/tests/test_utils.py
+++ b/gitlab/tests/test_utils.py
@@ -24,17 +24,17 @@ class TestUtils(unittest.TestCase):
def test_clean_str_id(self):
src = "nothing_special"
dest = "nothing_special"
- self.assertEqual(dest, utils.clean_str_id(src))
+ assert dest == utils.clean_str_id(src)
src = "foo#bar/baz/"
dest = "foo%23bar%2Fbaz%2F"
- self.assertEqual(dest, utils.clean_str_id(src))
+ assert dest == utils.clean_str_id(src)
def test_sanitized_url(self):
src = "http://localhost/foo/bar"
dest = "http://localhost/foo/bar"
- self.assertEqual(dest, utils.sanitized_url(src))
+ assert dest == utils.sanitized_url(src)
src = "http://localhost/foo.bar.baz"
dest = "http://localhost/foo%2Ebar%2Ebaz"
- self.assertEqual(dest, utils.sanitized_url(src))
+ assert dest == utils.sanitized_url(src)
View Lorry Controller Status