modules/fm-orchestrator
1
0
Fork 0
mirror of https://pagure.io/fm-orchestrator.git synced 2026-04-10 14:20:00 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change the format of the unit tests to pytest

Browse Source
This commit is contained in:
mprahl
2018-01-30 19:03:28 -05:00
parent fb8e9cf02c
commit e91d09f7ca
23 changed files with 719 additions and 796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
tests/__init__.py
View File

@@ -50,8 +50,25 @@ def patch_config():
patch_config()
def get_vcr_path(file_path, test_method):
cassette_dir = os.path.join(base_dir, 'vcr-request-data')
# In pytest style unit tests, we don't have access to self.id so this code replicates that
# value
filename_prefix = [os.path.abspath(os.path.dirname(file_path))]
while True:
if os.path.basename(filename_prefix[0]) == 'tests':
break
filename_prefix.insert(0, os.path.abspath(os.path.join(filename_prefix[0], os.pardir)))
filename_prefix = [os.path.basename(dir_path) for dir_path in filename_prefix]
filename = '.'.join(filename_prefix + [
os.path.splitext(os.path.basename(file_path))[0],
test_method.im_class.__name__,
test_method.im_func.__name__])
return os.path.join(cassette_dir, filename)
def uncompress_vcrpy_cassette():
cassette_dir = base_dir + '/vcr-request-data/'
cassette_dir = os.path.join(base_dir, 'vcr-request-data')
if not os.path.exists(cassette_dir):
archive = cassette_dir.rstrip('/') + ".tar.gz"
with tarfile.open(archive, mode='r:gz') as t:

47
tests/test_auth.py
View File

@@ -22,8 +22,7 @@
# Written by Matt Prahl <mprahl@redhat.com>
from os import path, environ
from nose.tools import eq_
import unittest
import pytest
import mock
from mock import patch, PropertyMock, Mock
import kerberos
@@ -35,7 +34,7 @@ import module_build_service.errors
import module_build_service.config as mbs_config
class TestAuthModule(unittest.TestCase):
class TestAuthModule:
def test_get_user_no_token(self):
base_dir = path.abspath(path.dirname(__file__))
client_secrets = path.join(base_dir, "client_secrets.json")
@@ -44,11 +43,9 @@ class TestAuthModule(unittest.TestCase):
request = mock.MagicMock()
request.cookies.return_value = {}
with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
with pytest.raises(module_build_service.errors.Unauthorized) as cm:
module_build_service.auth.get_user(request)
self.assertEquals(str(cm.exception),
"No 'authorization' header found.")
assert str(cm.value) == "No 'authorization' header found."
@patch('module_build_service.auth._get_token_info')
@patch('module_build_service.auth._get_user_info')
@@ -73,11 +70,9 @@ class TestAuthModule(unittest.TestCase):
request.headers.__setitem__.side_effect = headers.__setitem__
request.headers.__contains__.side_effect = headers.__contains__
with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
with pytest.raises(module_build_service.errors.Unauthorized) as cm:
module_build_service.auth.get_user(request)
self.assertEquals(str(cm.exception),
"OIDC token invalid or expired.")
assert str(cm.value) == "OIDC token invalid or expired."
@patch('module_build_service.auth._get_token_info')
@patch('module_build_service.auth._get_user_info')
@@ -103,24 +98,22 @@ class TestAuthModule(unittest.TestCase):
request.headers.__contains__.side_effect = headers.__contains__
username, groups = module_build_service.auth.get_user(request)
eq_(username, name)
eq_(groups, set(get_user_info.return_value["groups"]))
assert username == name
assert groups == set(get_user_info.return_value["groups"])
@patch.object(mbs_config.Config, 'no_auth', new_callable=PropertyMock, return_value=True)
def test_disable_authentication(self, conf_no_auth):
request = mock.MagicMock()
username, groups = module_build_service.auth.get_user(request)
eq_(username, "anonymous")
eq_(groups, {"packager"})
assert username == "anonymous"
assert groups == {"packager"}
@patch('module_build_service.auth.client_secrets', None)
def test_misconfiguring_oidc_client_secrets_should_be_failed(self):
request = mock.MagicMock()
with self.assertRaises(module_build_service.errors.Forbidden) as cm:
with pytest.raises(module_build_service.errors.Forbidden) as cm:
module_build_service.auth.get_user(request)
self.assertEquals(str(cm.exception),
"OIDC_CLIENT_SECRETS must be set in server config.")
assert str(cm.value) == "OIDC_CLIENT_SECRETS must be set in server config."
@patch('module_build_service.auth._get_token_info')
@patch('module_build_service.auth._get_user_info')
@@ -145,12 +138,10 @@ class TestAuthModule(unittest.TestCase):
request.headers.__setitem__.side_effect = headers.__setitem__
request.headers.__contains__.side_effect = headers.__contains__
with self.assertRaises(module_build_service.errors.Unauthorized) as cm:
with pytest.raises(module_build_service.errors.Unauthorized) as cm:
module_build_service.auth.get_user(request)
self.assertEquals(str(cm.exception),
"Required OIDC scope 'mbs-scope' not present: "
"['openid', 'https://id.fedoraproject.org/scope/groups']")
assert str(cm.value) == ("Required OIDC scope 'mbs-scope' not present: "
"['openid', 'https://id.fedoraproject.org/scope/groups']")
@patch('module_build_service.auth._get_token_info')
@patch('module_build_service.auth._get_user_info')
@@ -174,11 +165,9 @@ class TestAuthModule(unittest.TestCase):
request.headers.__setitem__.side_effect = headers.__setitem__
request.headers.__contains__.side_effect = headers.__contains__
with self.assertRaises(module_build_service.errors.Forbidden) as cm:
with pytest.raises(module_build_service.errors.Forbidden) as cm:
module_build_service.auth.get_user(request)
self.assertEquals(str(cm.exception),
"OIDC_REQUIRED_SCOPE must be set in server config.")
assert str(cm.value) == "OIDC_REQUIRED_SCOPE must be set in server config."
class KerberosMockConfig(object):
@@ -229,7 +218,7 @@ class KerberosMockConfig(object):
self.kerberos_http_host_p.stop()
class TestAuthModuleKerberos(unittest.TestCase):
class TestAuthModuleKerberos:
@patch('kerberos.authGSSServerInit', return_value=(kerberos.AUTH_GSS_COMPLETE, object()))
@patch('kerberos.authGSSServerStep', return_value=kerberos.AUTH_GSS_COMPLETE)
@patch('kerberos.authGSSServerResponse', return_value='STOKEN')

200
tests/test_build/test_build.py
View File

@@ -20,7 +20,6 @@
#
# Written by Jan Kaluza <jkaluza@redhat.com>
import unittest
import koji
import vcr
import os
@@ -37,6 +36,7 @@ import module_build_service.scheduler.handlers.repos
import module_build_service.utils
from module_build_service.errors import Forbidden
from module_build_service import db, models, conf, build_logs
from tests import get_vcr_path
from mock import patch, PropertyMock, Mock
import kobo
@@ -51,7 +51,6 @@ import module_build_service.scheduler.consumer
from module_build_service.messaging import MBSModule
base_dir = dirname(dirname(__file__))
cassette_dir = base_dir + '/vcr-request-data/'
user = ('Homer J. Simpson', set(['packager']))
@@ -302,21 +301,19 @@ def cleanup_moksha():
'info', 'bzip2', 'grep', 'redhat-rpm-config',
'diffutils', 'make', 'patch', 'shadow-utils',
'coreutils', 'which', 'rpm-build', 'gzip', 'gcc-c++'])})
class TestBuild(unittest.TestCase):
class TestBuild:
# Global variable used for tests if needed
_global_var = None
def setUp(self):
def setup_method(self, test_method):
GenericBuilder.register_backend_class(FakeModuleBuilder)
self.client = app.test_client()
clean_database()
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
FakeModuleBuilder.reset()
cleanup_moksha()
self.vcr.__exit__()
@@ -350,7 +347,7 @@ class TestBuild(unittest.TestCase):
tag_groups.append(set(['tangerine-1-1']))
def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
self.assertEqual(tag_groups.pop(0), set(artifacts))
assert tag_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
@@ -362,7 +359,7 @@ class TestBuild(unittest.TestCase):
buildroot_groups.append(set(['tangerine-1-1']))
def on_buildroot_add_artifacts_cb(cls, artifacts, install):
self.assertEqual(buildroot_groups.pop(0), set(artifacts))
assert buildroot_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
@@ -373,20 +370,20 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]
# All components has to be tagged, so tag_groups and buildroot_groups are empty...
self.assertEqual(tag_groups, [])
self.assertEqual(buildroot_groups, [])
assert tag_groups == []
assert buildroot_groups == []
module_build = models.ModuleBuild.query.get(module_build_id)
self.assertEqual(module_build.module_builds_trace[0].state, models.BUILD_STATES['init'])
self.assertEqual(module_build.module_builds_trace[1].state, models.BUILD_STATES['wait'])
self.assertEqual(module_build.module_builds_trace[2].state, models.BUILD_STATES['build'])
self.assertEqual(module_build.module_builds_trace[3].state, models.BUILD_STATES['done'])
self.assertEqual(module_build.module_builds_trace[4].state, models.BUILD_STATES['ready'])
self.assertEqual(len(module_build.module_builds_trace), 5)
assert module_build.module_builds_trace[0].state == models.BUILD_STATES['init']
assert module_build.module_builds_trace[1].state == models.BUILD_STATES['wait']
assert module_build.module_builds_trace[2].state == models.BUILD_STATES['build']
assert module_build.module_builds_trace[3].state == models.BUILD_STATES['done']
assert module_build.module_builds_trace[4].state == models.BUILD_STATES['ready']
assert len(module_build.module_builds_trace) == 5
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -411,9 +408,9 @@ class TestBuild(unittest.TestCase):
module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
# Make sure no component builds were registered
self.assertEqual(len(module_build.component_builds), 0)
assert len(module_build.component_builds) == 0
# Make sure the build is done
self.assertEqual(module_build.state, models.BUILD_STATES['ready'])
assert module_build.state == models.BUILD_STATES['ready']
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -432,8 +429,8 @@ class TestBuild(unittest.TestCase):
content_type='multipart/form-data',
data={'yaml': (testmodule, yaml)})
data = json.loads(rv.data)
self.assertEqual(data['status'], 403)
self.assertEqual(data['message'], 'YAML submission is not enabled')
assert data['status'] == 403
assert data['message'] == 'YAML submission is not enabled'
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -451,7 +448,7 @@ class TestBuild(unittest.TestCase):
content_type='multipart/form-data',
data={'yaml': (testmodule, yaml)})
data = json.loads(rv.data)
self.assertEqual(data['id'], 1)
assert data['id'] == 1
msgs = []
stop = module_build_service.scheduler.make_simple_stop_condition(db.session)
@@ -468,12 +465,12 @@ class TestBuild(unittest.TestCase):
return json.loads(rv.data)
data = submit(dict(params.items() + {"not_existing_param": "foo"}.items()))
self.assertIn("The request contains unspecified parameters:", data["message"])
self.assertIn("not_existing_param", data["message"])
self.assertEqual(data["status"], 400)
assert "The request contains unspecified parameters:" in data["message"]
assert "not_existing_param" in data["message"]
assert data["status"] == 400
data = submit(dict(params.items() + {"copr_owner": "foo"}.items()))
self.assertIn("The request contains parameters specific to Copr builder", data["message"])
assert "The request contains parameters specific to Copr builder" in data["message"]
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -518,14 +515,14 @@ class TestBuild(unittest.TestCase):
# module build, all components and even the module itself should be in
# failed state with state_reason se to cancellation message.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['FAILED'])
self.assertEqual(build.state_reason, "Canceled by Homer J. Simpson.")
self.assertEqual(build.module_build.state, models.BUILD_STATES["failed"])
self.assertEqual(build.module_build.state_reason, "Canceled by Homer J. Simpson.")
assert build.state == koji.BUILD_STATES['FAILED']
assert build.state_reason == "Canceled by Homer J. Simpson."
assert build.module_build.state == models.BUILD_STATES["failed"]
assert build.module_build.state_reason == "Canceled by Homer J. Simpson."
# Check that cancel_build has been called for this build
if build.task_id:
self.assertTrue(build.task_id in cancelled_tasks)
assert build.task_id in cancelled_tasks
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -553,9 +550,9 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -596,11 +593,11 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
assert build.state == koji.BUILD_STATES['COMPLETE']
# When this fails, it can mean that num_concurrent_builds
# threshold has been met.
self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]])
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -652,7 +649,7 @@ class TestBuild(unittest.TestCase):
# If we are building single component more often, num_concurrent_builds
# does not work correctly.
num_builds = [k for k, g in itertools.groupby(TestBuild._global_var)]
self.assertEqual(num_builds.count(1), 2)
assert num_builds.count(1) == 2
@timed(60)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -697,22 +694,22 @@ class TestBuild(unittest.TestCase):
for c in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
# perl-Tangerine is expected to fail as configured in on_build_cb.
if c.package == "perl-Tangerine":
self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
assert c.state == koji.BUILD_STATES['FAILED']
# tangerine is expected to fail, because it is in batch 3, but
# we had a failing component in batch 2.
elif c.package == "tangerine":
self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
self.assertEqual(c.state_reason, "Some components failed to build.")
assert c.state == koji.BUILD_STATES['FAILED']
assert c.state_reason == "Some components failed to build."
else:
self.assertEqual(c.state, koji.BUILD_STATES['COMPLETE'])
assert c.state == koji.BUILD_STATES['COMPLETE']
# Whole module should be failed.
self.assertEqual(c.module_build.state, models.BUILD_STATES['failed'])
self.assertEqual(c.module_build.state_reason, "Some components failed to build.")
assert c.module_build.state == models.BUILD_STATES['failed']
assert c.module_build.state_reason == "Some components failed to build."
# We should end up with batch 2 and never start batch 3, because
# there were failed components in batch 2.
self.assertEqual(c.module_build.batch, 2)
assert c.module_build.batch == 2
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -750,17 +747,17 @@ class TestBuild(unittest.TestCase):
for c in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
# perl-Tangerine is expected to fail as configured in on_build_cb.
if c.package == "module-build-macros":
self.assertEqual(c.state, koji.BUILD_STATES['COMPLETE'])
assert c.state == koji.BUILD_STATES['COMPLETE']
else:
self.assertEqual(c.state, koji.BUILD_STATES['FAILED'])
assert c.state == koji.BUILD_STATES['FAILED']
# Whole module should be failed.
self.assertEqual(c.module_build.state, models.BUILD_STATES['failed'])
self.assertEqual(c.module_build.state_reason, "Some components failed to build.")
assert c.module_build.state == models.BUILD_STATES['failed']
assert c.module_build.state_reason == "Some components failed to build."
# We should end up with batch 2 and never start batch 3, because
# there were failed components in batch 2.
self.assertEqual(c.module_build.batch, 2)
assert c.module_build.batch == 2
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -786,7 +783,7 @@ class TestBuild(unittest.TestCase):
def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
if dest_tag is True:
self.assertEqual(tag_groups.pop(0), set(artifacts))
assert tag_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
buildtag_groups = []
@@ -796,7 +793,7 @@ class TestBuild(unittest.TestCase):
'tangerine-0.22-3.module+0+814cfa39']))
def on_buildroot_add_artifacts_cb(cls, artifacts, install):
self.assertEqual(buildtag_groups.pop(0), set(artifacts))
assert buildtag_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
msgs = [MBSModule("local module build", 2, 1)]
@@ -809,12 +806,10 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=2).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]])
self.assertEqual(build.reused_component_id,
reused_component_ids[build.package])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]
assert build.reused_component_id == reused_component_ids[build.package]
@timed(30)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -828,8 +823,7 @@ class TestBuild(unittest.TestCase):
test_reuse_component_init_data()
models.ComponentBuild.query.filter_by(package="module-build-macros").delete()
self.assertEqual(len(models.ComponentBuild.query.filter_by(
package="module-build-macros").all()), 0)
assert len(models.ComponentBuild.query.filter_by(package="module-build-macros").all()) == 0
db.session.commit()
@@ -846,7 +840,7 @@ class TestBuild(unittest.TestCase):
def on_tag_artifacts_cb(cls, artifacts, dest_tag=True):
if dest_tag is True:
self.assertEqual(tag_groups.pop(0), set(artifacts))
assert tag_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_tag_artifacts_cb = on_tag_artifacts_cb
buildtag_groups = []
@@ -856,7 +850,7 @@ class TestBuild(unittest.TestCase):
'tangerine-0.22-3.module+0+814cfa39']))
def on_buildroot_add_artifacts_cb(cls, artifacts, install):
self.assertEqual(buildtag_groups.pop(0), set(artifacts))
assert buildtag_groups.pop(0) == set(artifacts)
FakeModuleBuilder.on_buildroot_add_artifacts_cb = on_buildroot_add_artifacts_cb
msgs = [MBSModule("local module build", 2, 1)]
@@ -866,10 +860,10 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=2).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]])
self.assertNotEqual(build.package, "module-build-macros")
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]
assert build.package != "module-build-macros"
@timed(60)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -973,10 +967,10 @@ class TestBuild(unittest.TestCase):
components = models.ComponentBuild.query.filter_by(
module_id=module_build_id, batch=2).order_by(models.ComponentBuild.id).all()
# Make sure the build went from failed to wait
self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
assert module_build.state == models.BUILD_STATES['wait']
assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
# Make sure the state was reset on the failed component
self.assertIsNone(components[1].state)
assert components[1].state is None
db.session.expire_all()
# Run the backend
@@ -987,9 +981,9 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']]
@timed(60)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -1084,11 +1078,11 @@ class TestBuild(unittest.TestCase):
module_build_id = data['id']
module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
# Make sure the build went from failed to wait
self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
assert module_build.state == models.BUILD_STATES['wait']
assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
# Make sure the state was reset on the failed component
for c in module_build.component_builds:
self.assertIsNone(c.state)
assert c.state is None
db.session.expire_all()
# Run the backend
@@ -1099,9 +1093,9 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']]
@timed(60)
@patch('module_build_service.auth.get_user', return_value=user)
@@ -1125,12 +1119,11 @@ class TestBuild(unittest.TestCase):
module_build_id = json.loads(rv.data)['id']
module_build = models.ModuleBuild.query.filter_by(id=module_build_id).one()
self.assertEqual(module_build.state, models.BUILD_STATES['failed'])
self.assertEqual(
module_build.state_reason, 'Custom component repositories aren\'t allowed.')
self.assertEqual(len(module_build.module_builds_trace), 2)
self.assertEqual(module_build.module_builds_trace[0].state, models.BUILD_STATES['init'])
self.assertEqual(module_build.module_builds_trace[1].state, models.BUILD_STATES['failed'])
assert module_build.state == models.BUILD_STATES['failed']
assert module_build.state_reason == 'Custom component repositories aren\'t allowed.'
assert len(module_build.module_builds_trace) == 2
assert module_build.module_builds_trace[0].state == models.BUILD_STATES['init']
assert module_build.module_builds_trace[1].state == models.BUILD_STATES['failed']
# Resubmit the failed module
rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
@@ -1141,10 +1134,10 @@ class TestBuild(unittest.TestCase):
components = models.ComponentBuild.query.filter_by(
module_id=module_build_id, batch=2).order_by(models.ComponentBuild.id).all()
# Make sure the build went from failed to init
self.assertEqual(module_build.state, models.BUILD_STATES['init'])
self.assertEqual(module_build.state_reason, 'Resubmitted by Homer J. Simpson')
assert module_build.state == models.BUILD_STATES['init']
assert module_build.state_reason == 'Resubmitted by Homer J. Simpson'
# Make sure there are no components
self.assertEqual(components, [])
assert components == []
db.session.expire_all()
# Run the backend again
@@ -1153,9 +1146,9 @@ class TestBuild(unittest.TestCase):
# All components should be built and module itself should be in "done"
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES['done'],
models.BUILD_STATES['ready']]
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -1169,7 +1162,7 @@ class TestBuild(unittest.TestCase):
rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#68932c90de214d9d13feefbd35246a81b6cb8d49'}))
self.assertEqual(rv.status_code, 201)
assert rv.status_code == 201
# Run the backend
stop = module_build_service.scheduler.make_simple_stop_condition(db.session)
module_build_service.scheduler.main([], stop)
@@ -1184,25 +1177,24 @@ class TestBuild(unittest.TestCase):
'failed build is allowed.'),
'status': 409
}
self.assertEqual(data, expected)
assert data == expected
@patch("module_build_service.config.Config.system",
new_callable=PropertyMock, return_value="testlocal")
class TestLocalBuild(unittest.TestCase):
class TestLocalBuild:
def setUp(self):
def setup_method(self, test_method):
FakeModuleBuilder.on_build_cb = None
FakeModuleBuilder.backend = 'testlocal'
GenericBuilder.register_backend_class(FakeModuleBuilder)
self.client = app.test_client()
clean_database()
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
FakeModuleBuilder.reset()
cleanup_moksha()
self.vcr.__exit__()
@@ -1254,6 +1246,6 @@ class TestLocalBuild(unittest.TestCase):
# or "ready" state.
for build in models.ComponentBuild.query.filter_by(
module_id=module_build_id).all():
self.assertEqual(build.state, koji.BUILD_STATES['COMPLETE'])
self.assertTrue(build.module_build.state in [
models.BUILD_STATES["done"], models.BUILD_STATES["ready"]])
assert build.state == koji.BUILD_STATES['COMPLETE']
assert build.module_build.state in [models.BUILD_STATES["done"],
models.BUILD_STATES["ready"]]

13
tests/test_builder/test_base.py
View File

@@ -21,7 +21,6 @@
# Written by Jan Kaluza <jkaluza@redhat.com>
import mock
import unittest
import module_build_service.models
import module_build_service.builder
@@ -32,9 +31,9 @@ from module_build_service.builder import GenericBuilder
from mock import patch
class TestGenericBuilder(unittest.TestCase):
class TestGenericBuilder:
def setUp(self):
def setup_method(self, test_method):
init_data()
self.module = module_build_service.models.ModuleBuild.query.filter_by(id=1).one()
@@ -58,23 +57,23 @@ class TestGenericBuilder(unittest.TestCase):
# Call default_buildroot_groups, the result should be cached.
ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
self.assertEqual(ret, expected_groups)
assert ret == expected_groups
resolver.resolve_profiles.assert_called_once()
resolver.resolve_profiles.reset_mock()
# Now try calling it again to verify resolve_profiles is not called,
# because it is cached.
ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
self.assertEqual(ret, expected_groups)
assert ret == expected_groups
resolver.resolve_profiles.assert_not_called()
resolver.resolve_profiles.reset_mock()
# And now try clearing the cache and call it again.
GenericBuilder.clear_cache(self.module)
ret = GenericBuilder.default_buildroot_groups(db.session, self.module)
self.assertEqual(ret, expected_groups)
assert ret == expected_groups
resolver.resolve_profiles.assert_called_once()
def test_get_build_weights(self):
weights = GenericBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
assert weights == {"httpd": 1.5, "apr": 1.5}

7
tests/test_builder/test_builder_utils.py
View File

@@ -20,7 +20,6 @@
#
# Written by Matt Prahl <mprahl@redhat.com>
import unittest
import tempfile
import shutil
@@ -30,7 +29,7 @@ from module_build_service.builder import utils
from tests import conf
class TestBuilderUtils(unittest.TestCase):
class TestBuilderUtils:
@patch('requests.get')
@patch('koji.ClientSession')
@@ -137,5 +136,5 @@ class TestBuilderUtils(unittest.TestCase):
call(url_three, stream=True, timeout=60)
]
for expected_call in expected_calls:
self.assertIn(expected_call, mock_get.call_args_list)
self.assertEqual(len(mock_get.call_args_list), len(expected_calls))
assert expected_call in mock_get.call_args_list
assert len(mock_get.call_args_list) == len(expected_calls)

68
tests/test_builder/test_copr.py
View File

@@ -22,8 +22,8 @@
import os
import unittest
import mock
import pytest
import module_build_service.models
import module_build_service.builder
from munch import Munch
@@ -33,10 +33,11 @@ from copr import CoprClient
from copr.exceptions import CoprRequestException
@unittest.skip("We need not yet released version of python-copr. Let's skip this for some time")
class TestCoprBuilder(unittest.TestCase):
@pytest.mark.skip(
reason="We need not yet released version of python-copr. Let's skip this for some time")
class TestCoprBuilder:
def setUp(self):
def setup_method(self, test_method):
self.config = mock.Mock()
self.config.copr_config = None
@@ -53,16 +54,15 @@ class TestCoprBuilder(unittest.TestCase):
repo = module_build_service.builder.GenericBuilder.tag_to_repo(
"copr", self.config, "foo-module-name-0.25-9", None)
self.assertEquals(repo,
"http://copr-be-instance/results/@copr/foo-module-name-0.25-9/modules")
assert repo == "http://copr-be-instance/results/@copr/foo-module-name-0.25-9/modules"
@mock.patch("copr.CoprClient.get_module_repo")
def test_non_existing_tag_to_repo(self, get_module_repo):
# Let's pretend that CoprClient.get_module_repo couldn't find the project on Copr instance
get_module_repo.return_value = ResponseMock({"output": "notok", "error": "some error"})
self.assertRaises(ValueError,
lambda: module_build_service.builder.GenericBuilder.tag_to_repo(
"copr", self.config, None, None))
with pytest.raises(ValueError):
lambda: module_build_service.builder.GenericBuilder.tag_to_repo(
"copr", self.config, None, None)
class ResponseMock(object):
@@ -97,9 +97,9 @@ class FakeCoprAPI(object):
COPR_MODULE_BUILDER = "module_build_service.builder.CoprModuleBuilder.CoprModuleBuilder"
class TestCoprModuleBuilder(unittest.TestCase):
class TestCoprModuleBuilder:
def setUp(self):
def setup_method(self, test_method):
init_data()
self.config = mock.Mock()
self.config.koji_profile = conf.koji_profile
@@ -132,8 +132,8 @@ class TestCoprModuleBuilder(unittest.TestCase):
args, kwargs = make_module.call_args
make_module.assert_called_with(username="myself", projectname="someproject",
modulemd=mock.ANY, create=False, build=True)
self.assertIsInstance(kwargs["modulemd"], str)
self.assertTrue(os.path.isabs(kwargs["modulemd"]))
assert isinstance(kwargs["modulemd"], str)
assert os.path.isabs(kwargs["modulemd"]) is True
###############################################################################################
# #
@@ -142,7 +142,7 @@ class TestCoprModuleBuilder(unittest.TestCase):
# #
###############################################################################################
@unittest.skip("Tests fail since PR 765")
@pytest.mark.skip("Tests fail since PR 765")
@mock.patch(COPR_MODULE_BUILDER + "._update_chroot")
@mock.patch(COPR_MODULE_BUILDER + "._get_copr_safe")
@mock.patch(COPR_MODULE_BUILDER + "._create_module_safe")
@@ -151,10 +151,10 @@ class TestCoprModuleBuilder(unittest.TestCase):
groups = {"build": {"pkgname1", "pkgname2", "pkgname3"}}
builder.buildroot_connect(groups)
args, kwargs = update_chroot.call_args
self.assertEquals(set(kwargs["packages"]), {"pkgname1", "pkgname2", "pkgname3"})
self.assertEqual(builder._CoprModuleBuilder__prep, True)
assert set(kwargs["packages"]) == {"pkgname1", "pkgname2", "pkgname3"}
assert builder._CoprModuleBuilder__prep is True
@unittest.skip("Tests fail since PR 765")
@pytest.mark.skip("Tests fail since PR 765")
@mock.patch(COPR_MODULE_BUILDER + "._get_copr")
@mock.patch(COPR_MODULE_BUILDER + "._create_copr")
@mock.patch(COPR_MODULE_BUILDER + "._create_chroot_safe")
@@ -174,14 +174,14 @@ class TestCoprModuleBuilder(unittest.TestCase):
builder._get_copr_safe()
get_copr.assert_called_with(ownername=self.module.owner, projectname="module-nginx-1.2")
create_copr.assert_called_with(ownername=self.module.owner, projectname="module-nginx-1.2")
self.assertEqual(get_copr.call_count, 2)
assert get_copr.call_count == 2
@mock.patch("copr.client.CoprClient._fetch", return_value=FakeCoprAPI.get_project_details())
def test_get_copr(self, get_project_details):
builder = self.create_builder()
copr = builder._get_copr("myself", "someproject")
self.assertEqual(copr.username, "myself")
self.assertEqual(copr.projectname, "someproject")
assert copr.username == "myself"
assert copr.projectname == "someproject"
@mock.patch("copr.client.CoprClient.create_project")
def test_create_copr(self, create_project):
@@ -196,12 +196,12 @@ class TestCoprModuleBuilder(unittest.TestCase):
make_module.assert_called_with(username=self.module.owner, projectname="module-nginx-1.2",
modulemd=mock.ANY, create=True, build=False)
args, kwargs = make_module.call_args
self.assertIsInstance(kwargs["modulemd"], str)
self.assertTrue(os.path.isabs(kwargs["modulemd"]))
assert isinstance(kwargs["modulemd"], str)
assert os.path.isabs(kwargs["modulemd"]) is True
def test_buildroot_ready(self):
builder = self.create_builder()
self.assertTrue(builder.buildroot_ready(artifacts=["a1", "a2", "a3"]))
assert builder.buildroot_ready(artifacts=["a1", "a2", "a3"]) is True
##############################################################################################
# #
@@ -221,37 +221,37 @@ class TestCoprModuleBuilder(unittest.TestCase):
edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
repos=mock.ANY, packages=mock.ANY)
args, kwargs = edit_chroot.call_args
self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"})
self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/"})
assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"}
assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/"}
# Update buildroot repos
builder._update_chroot(repos=["http://repo3.ex/"])
edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
repos=mock.ANY, packages=mock.ANY)
args, kwargs = edit_chroot.call_args
self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3"})
self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/",
"http://repo3.ex/"})
assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3"}
assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/",
"http://repo3.ex/"}
# Update multiple buildroot options at the same time
builder._update_chroot(packages=["pkg4", "pkg5"], repos=["http://repo3.ex/"])
edit_chroot.assert_called_with("someproject", "custom-1-x86_64", ownername="myself",
repos=mock.ANY, packages=mock.ANY)
args, kwargs = edit_chroot.call_args
self.assertEqual(set(kwargs["packages"].split()), {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"})
self.assertEqual(set(kwargs["repos"].split()), {"http://repo1.ex/", "http://repo2.ex/",
"http://repo3.ex/"})
assert set(kwargs["packages"].split()) == {"pkg1", "pkg2", "pkg3", "pkg4", "pkg5"}
assert set(kwargs["repos"].split()) == {"http://repo1.ex/", "http://repo2.ex/",
"http://repo3.ex/"}
def test_buildroot_add_artifacts(self):
pass
@unittest.skip("Tests fail since PR 765")
@pytest.mark.skip("Tests fail since PR 765")
@mock.patch(COPR_MODULE_BUILDER + "._update_chroot")
def test_buildroot_add_repos(self, update_chroot):
builder = self.create_builder()
builder.buildroot_add_repos(["foo", "bar", "baz"])
args, kwargs = update_chroot.call_args
self.assertEquals(set(kwargs["repos"]), {
assert set(kwargs["repos"]) == {
conf.koji_repository_url + "/foo/latest/x86_64",
conf.koji_repository_url + "/bar/latest/x86_64",
conf.koji_repository_url + "/baz/latest/x86_64",
@@ -259,7 +259,7 @@ class TestCoprModuleBuilder(unittest.TestCase):
# We always add this repo as a workaround, see the code for details
("https://kojipkgs.fedoraproject.org/compose"
"/latest-Fedora-Modular-26/compose/Server/x86_64/os/"),
})
}
##############################################################################################
# #

107
tests/test_builder/test_koji.py
View File

@@ -20,7 +20,6 @@
#
# Written by Jan Kaluza <jkaluza@redhat.com>
import unittest
import mock
import koji
import xmlrpclib
@@ -30,6 +29,7 @@ import module_build_service.scheduler.handlers.repos
import module_build_service.models
import module_build_service.builder
import pytest
from mock import patch, MagicMock
from tests import conf, init_data
@@ -52,9 +52,9 @@ class FakeKojiModuleBuilder(KojiModuleBuilder):
return koji_session
class TestKojiBuilder(unittest.TestCase):
class TestKojiBuilder:
def setUp(self):
def setup_method(self, test_method):
init_data()
self.config = mock.Mock()
self.config.koji_profile = conf.koji_profile
@@ -69,8 +69,8 @@ class TestKojiBuilder(unittest.TestCase):
"koji", self.config,
"module-base-runtime-0.25-9",
"x86_64")
self.assertEquals(repo, "https://kojipkgs.stg.fedoraproject.org/repos"
"/module-base-runtime-0.25-9/latest/x86_64")
assert repo == ("https://kojipkgs.stg.fedoraproject.org/repos"
"/module-base-runtime-0.25-9/latest/x86_64")
def test_recover_orphaned_artifact_when_tagged(self):
""" Test recover_orphaned_artifact when the artifact is found and tagged in both tags
@@ -95,25 +95,25 @@ class TestKojiBuilder(unittest.TestCase):
component_build.nvr = None
actual = builder.recover_orphaned_artifact(component_build)
self.assertEqual(len(actual), 3)
self.assertEquals(type(actual[0]), module_build_service.messaging.KojiBuildChange)
self.assertEquals(actual[0].build_id, 91)
self.assertEquals(actual[0].task_id, 12345)
self.assertEquals(actual[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
self.assertEquals(actual[0].build_name, 'rubygem-rails')
self.assertEquals(actual[0].build_version, '1.0')
self.assertEquals(actual[0].build_release, '1.module+e0095747')
self.assertEquals(actual[0].module_build_id, 30)
self.assertEquals(type(actual[1]), module_build_service.messaging.KojiTagChange)
self.assertEquals(actual[1].tag, 'module-foo-build')
self.assertEquals(actual[1].artifact, 'rubygem-rails')
self.assertEquals(type(actual[2]), module_build_service.messaging.KojiTagChange)
self.assertEquals(actual[2].tag, 'module-foo')
self.assertEquals(actual[2].artifact, 'rubygem-rails')
self.assertEqual(component_build.state, koji.BUILD_STATES['COMPLETE'])
self.assertEqual(component_build.task_id, 12345)
self.assertEqual(component_build.state_reason, 'Found existing build')
self.assertEquals(builder.koji_session.tagBuild.call_count, 0)
assert len(actual) == 3
assert type(actual[0]) == module_build_service.messaging.KojiBuildChange
assert actual[0].build_id == 91
assert actual[0].task_id == 12345
assert actual[0].build_new_state == koji.BUILD_STATES['COMPLETE']
assert actual[0].build_name == 'rubygem-rails'
assert actual[0].build_version == '1.0'
assert actual[0].build_release == '1.module+e0095747'
assert actual[0].module_build_id == 30
assert type(actual[1]) == module_build_service.messaging.KojiTagChange
assert actual[1].tag == 'module-foo-build'
assert actual[1].artifact == 'rubygem-rails'
assert type(actual[2]) == module_build_service.messaging.KojiTagChange
assert actual[2].tag == 'module-foo'
assert actual[2].artifact == 'rubygem-rails'
assert component_build.state == koji.BUILD_STATES['COMPLETE']
assert component_build.task_id == 12345
assert component_build.state_reason == 'Found existing build'
assert builder.koji_session.tagBuild.call_count == 0
def test_recover_orphaned_artifact_when_untagged(self):
""" Tests recover_orphaned_artifact when the build is found but untagged
@@ -149,19 +149,18 @@ class TestKojiBuilder(unittest.TestCase):
component_build.state = None
actual = builder.recover_orphaned_artifact(component_build)
self.assertEqual(len(actual), 1)
self.assertEquals(type(actual[0]), module_build_service.messaging.KojiBuildChange)
self.assertEquals(actual[0].build_id, 91)
self.assertEquals(actual[0].task_id, 12345)
self.assertEquals(actual[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
self.assertEquals(actual[0].build_name, 'rubygem-rails')
self.assertEquals(actual[0].build_version, '1.0')
self.assertEquals(
actual[0].build_release, '1.{0}'.format(dist_tag))
self.assertEquals(actual[0].module_build_id, 30)
self.assertEqual(component_build.state, koji.BUILD_STATES['COMPLETE'])
self.assertEqual(component_build.task_id, 12345)
self.assertEqual(component_build.state_reason, 'Found existing build')
assert len(actual) == 1
assert type(actual[0]) == module_build_service.messaging.KojiBuildChange
assert actual[0].build_id == 91
assert actual[0].task_id == 12345
assert actual[0].build_new_state == koji.BUILD_STATES['COMPLETE']
assert actual[0].build_name == 'rubygem-rails'
assert actual[0].build_version == '1.0'
assert actual[0].build_release == '1.{0}'.format(dist_tag)
assert actual[0].module_build_id == 30
assert component_build.state == koji.BUILD_STATES['COMPLETE']
assert component_build.task_id == 12345
assert component_build.state_reason == 'Found existing build'
builder.koji_session.tagBuild.assert_called_once_with(2, 'foo-1.0-1.{0}'.format(dist_tag))
def test_recover_orphaned_artifact_when_nothing_exists(self):
@@ -191,9 +190,9 @@ class TestKojiBuilder(unittest.TestCase):
component_build.state = None
actual = builder.recover_orphaned_artifact(component_build)
self.assertEqual(actual, [])
assert actual == []
# Make sure nothing erroneous gets tag
self.assertEquals(builder.koji_session.tagBuild.call_count, 0)
assert builder.koji_session.tagBuild.call_count == 0
@patch('koji.util')
def test_buildroot_ready(self, mocked_kojiutil):
@@ -208,9 +207,9 @@ class TestKojiBuilder(unittest.TestCase):
components=[])
fake_kmb.module_target = {'build_tag': 'module-fake_tag'}
with self.assertRaises(IOError):
with pytest.raises(IOError):
fake_kmb.buildroot_ready()
self.assertEquals(mocked_kojiutil.checkForBuilds.call_count, 3)
assert mocked_kojiutil.checkForBuilds.call_count == 3
def test_tagging_already_tagged_artifacts(self):
"""
@@ -261,9 +260,9 @@ class TestKojiBuilder(unittest.TestCase):
components=[])
builder.untag_artifacts(['foo', 'bar'])
self.assertEqual(mock_session.untagBuild.call_count, 3)
assert mock_session.untagBuild.call_count == 3
expected_calls = [mock.call(1, 'foo'), mock.call(2, 'foo'), mock.call(1, 'bar')]
self.assertEqual(mock_session.untagBuild.mock_calls, expected_calls)
assert mock_session.untagBuild.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights(self, get_session):
@@ -281,10 +280,10 @@ class TestKojiBuilder(unittest.TestCase):
get_session.return_value = session
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 2, "apr": 2})
assert weights == {"httpd": 2, "apr": 2}
expected_calls = [mock.call(456), mock.call(789)]
self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
assert session.getTaskDescendents.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights_no_task_id(self, get_session):
@@ -301,10 +300,10 @@ class TestKojiBuilder(unittest.TestCase):
get_session.return_value = session
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 2, "apr": 1.5})
assert weights == {"httpd": 2, "apr": 1.5}
expected_calls = [mock.call(456)]
self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
assert session.getTaskDescendents.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights_no_build(self, get_session):
@@ -321,10 +320,10 @@ class TestKojiBuilder(unittest.TestCase):
get_session.return_value = session
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 2, "apr": 1.5})
assert weights == {"httpd": 2, "apr": 1.5}
expected_calls = [mock.call(456)]
self.assertEqual(session.getTaskDescendents.mock_calls, expected_calls)
assert session.getTaskDescendents.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights_listBuilds_failed(self, get_session):
@@ -334,13 +333,13 @@ class TestKojiBuilder(unittest.TestCase):
get_session.return_value = session
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
assert weights == {"httpd": 1.5, "apr": 1.5}
expected_calls = [mock.call(packageID=1, userID=123, state=1,
queryOpts={'limit': 1, 'order': '-build_id'}),
mock.call(packageID=2, userID=123, state=1,
queryOpts={'limit': 1, 'order': '-build_id'})]
self.assertEqual(session.listBuilds.mock_calls, expected_calls)
assert session.listBuilds.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights_getPackageID_failed(self, get_session):
@@ -350,12 +349,12 @@ class TestKojiBuilder(unittest.TestCase):
get_session.return_value = session
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
assert weights == {"httpd": 1.5, "apr": 1.5}
expected_calls = [mock.call("httpd"), mock.call("apr")]
self.assertEqual(session.getPackageID.mock_calls, expected_calls)
assert session.getPackageID.mock_calls == expected_calls
@patch('module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session')
def test_get_build_weights_getLoggedInUser_failed(self, get_session):
weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])
self.assertEqual(weights, {"httpd": 1.5, "apr": 1.5})
assert weights == {"httpd": 1.5, "apr": 1.5}

12
tests/test_builder/test_mock.py
View File

@@ -1,5 +1,4 @@
import os
import unittest
import mock
import koji
import tempfile
@@ -10,17 +9,16 @@ import kobo.rpmlib
from module_build_service import conf
from module_build_service.models import ModuleBuild, ComponentBuild, make_session
from module_build_service.builder.MockModuleBuilder import MockModuleBuilder
from tests import db, init_data
from tests import init_data, clean_database
class TestMockModuleBuilder(unittest.TestCase):
class TestMockModuleBuilder:
def setUp(self):
db.drop_all()
db.create_all()
def setup_method(self, test_method):
clean_database()
self.resultdir = tempfile.mkdtemp()
def tearDown(self):
def teardown_method(self, test_method):
init_data()
shutil.rmtree(self.resultdir)

7
tests/test_config.py
View File

@@ -20,18 +20,17 @@
#
# Written by Jan Kaluza <jkaluza@redhat.com>
import unittest
import os.path
from module_build_service import conf
class TestConfig(unittest.TestCase):
class TestConfig:
def test_path_expanduser(self):
test_dir = "~/modulebuild/builds"
conf.mock_resultsdir = test_dir
self.assertEqual(conf.mock_resultsdir, os.path.expanduser(test_dir))
assert conf.mock_resultsdir == os.path.expanduser(test_dir)
test_dir = "~/modulebuild/builds"
conf.cache_dir = test_dir
self.assertEqual(conf.cache_dir, os.path.expanduser(test_dir))
assert conf.cache_dir == os.path.expanduser(test_dir)

39
tests/test_content_generator.py
View File

@@ -20,13 +20,11 @@
#
# Written by Stanislav Ochotnicky <sochotnicky@redhat.com>
import unittest
import json
import vcr
import os
from os import path
from os.path import dirname
import module_build_service.messaging
import module_build_service.scheduler.handlers.repos # noqa
@@ -34,7 +32,7 @@ from module_build_service import models, conf, build_logs
from mock import patch, Mock, MagicMock, call
from tests import init_data
from tests import init_data, get_vcr_path
from module_build_service.builder.KojiContentGenerator import KojiContentGenerator
@@ -45,33 +43,27 @@ GET_USER_RV = {
"status": 0,
"usertype": 0
}
base_dir = dirname(dirname(__file__))
cassette_dir = base_dir + '/vcr-request-data/'
class TestBuild(unittest.TestCase):
class TestBuild:
# Global variable used for tests if needed
_global_var = None
def setUp(self):
def setup_method(self, test_method):
init_data()
module = models.ModuleBuild.query.filter_by(id=1).one()
module.cg_build_koji_tag = "f27-module-candidate"
self.cg = KojiContentGenerator(module, conf)
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
# Ensure that there is no build log from other tests
try:
path = build_logs.path(self.cg.module)
os.remove(path)
file_path = build_logs.path(self.cg.module)
os.remove(file_path)
except OSError:
pass
def tearDown(self):
def teardown_method(self, test_method):
# Necessary to restart the twisted reactor for the next test.
import sys
del sys.modules['twisted.internet.reactor']
@@ -80,8 +72,8 @@ class TestBuild(unittest.TestCase):
import moksha.hub.reactor # noqa
self.vcr.__exit__()
try:
path = build_logs.path(self.cg.module)
os.remove(path)
file_path = build_logs.path(self.cg.module)
os.remove(file_path)
except OSError:
pass
@@ -98,7 +90,6 @@ class TestBuild(unittest.TestCase):
koji_session.getUser.return_value = GET_USER_RV
get_session.return_value = koji_session
distro.return_value = ("Fedora", "25", "Twenty Five")
self.maxDiff = None
machine.return_value = "i686"
pkg_res.return_value = Mock()
pkg_res.return_value.version = "current-tested-version"
@@ -128,7 +119,7 @@ class TestBuild(unittest.TestCase):
file_dir = self.cg._prepare_file_directory()
ret = self.cg._get_content_generator_metadata(file_dir)
rpms_in_tag.assert_called_once()
self.assertEqual(expected_output, ret)
assert expected_output == ret
@patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
@patch("subprocess.Popen")
@@ -168,13 +159,13 @@ class TestBuild(unittest.TestCase):
file_dir = self.cg._prepare_file_directory()
ret = self.cg._get_content_generator_metadata(file_dir)
rpms_in_tag.assert_called_once()
self.assertEqual(expected_output, ret)
assert expected_output == ret
def test_prepare_file_directory(self):
""" Test preparation of directory with output files """
dir_path = self.cg._prepare_file_directory()
with open(path.join(dir_path, "modulemd.txt")) as mmd:
self.assertEqual(len(mmd.read()), 1134)
assert len(mmd.read()) == 1134
@patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
def test_tag_cg_build(self, get_session):
@@ -199,9 +190,9 @@ class TestBuild(unittest.TestCase):
self.cg._tag_cg_build()
self.assertEqual(koji_session.getTag.mock_calls,
[call(self.cg.module.cg_build_koji_tag),
call(conf.koji_cg_default_build_tag)])
assert koji_session.getTag.mock_calls == [
call(self.cg.module.cg_build_koji_tag),
call(conf.koji_cg_default_build_tag)]
koji_session.tagBuild.assert_called_once_with(123, "nginx-1-2.00000000")
@patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")

32
tests/test_logger.py
View File

@@ -22,9 +22,9 @@
import os
from os import path
import shutil
import tempfile
import unittest
from module_build_service import log, models
from module_build_service.logger import ModuleBuildLogs
@@ -32,16 +32,20 @@ from module_build_service.scheduler.consumer import MBSConsumer
from tests import init_data
class TestLogger(unittest.TestCase):
class TestLogger:
def setUp(self):
def setup_method(self, test_method):
init_data()
self.base = tempfile.mkdtemp(prefix='mbs-', suffix='-%s' % self.id())
test_id = '.'.join([
path.splitext(path.basename(__file__))[0],
test_method.im_class.__name__,
test_method.im_func.__name__])
self.base = tempfile.mkdtemp(prefix='mbs-', suffix='-%s' % test_id)
self.name_format = "build-{id}.log"
print("Storing build logs in %r" % self.base)
self.build_log = ModuleBuildLogs(self.base, self.name_format)
def tearDown(self):
def teardown_method(self, test_method):
MBSConsumer.current_module_build_id = None
shutil.rmtree(self.base)
@@ -55,7 +59,7 @@ class TestLogger(unittest.TestCase):
# ensure we are not using some garbage from previous failed test.
self.build_log.start(build)
path = self.build_log.path(build)
self.assertEqual(path[len(self.base):], "/build-1.log")
assert path[len(self.base):] == "/build-1.log"
if os.path.exists(path):
os.unlink(path)
@@ -66,7 +70,7 @@ class TestLogger(unittest.TestCase):
log.warn("ignore this test msg")
log.error("ignore this test msg")
self.build_log.stop(build)
self.assertTrue(not os.path.exists(path))
assert not os.path.exists(path)
# Try logging with current_module_build_id set to 1 and then to 2.
# Only messages with current_module_build_id set to 1 should appear in
@@ -85,12 +89,12 @@ class TestLogger(unittest.TestCase):
log.error("ignore this test msg2")
self.build_log.stop(build)
self.assertTrue(os.path.exists(path))
assert os.path.exists(path)
with open(path, "r") as f:
data = f.read()
# Note that DEBUG is not present unless configured server-wide.
for level in ["INFO", "WARNING", "ERROR"]:
self.assertTrue(data.find("%s - ignore this test msg1" % level) != -1)
assert data.find("%s - ignore this test msg1" % level) != -1
# Try to log more messages when build_log for module 1 is stopped.
# New messages should not appear in a log.
@@ -102,15 +106,15 @@ class TestLogger(unittest.TestCase):
self.build_log.stop(build)
with open(path, "r") as f:
data = f.read()
self.assertTrue(data.find("ignore this test msg3") == -1)
assert data.find("ignore this test msg3") == -1
def test_module_build_logs_name_format(self):
build = models.ModuleBuild.query.filter_by(id=1).one()
log1 = ModuleBuildLogs("/some/path", "build-{id}.log")
self.assertEquals(log1.name(build), "build-1.log")
self.assertEquals(log1.path(build), "/some/path/build-1.log")
assert log1.name(build) == "build-1.log"
assert log1.path(build) == "/some/path/build-1.log"
log2 = ModuleBuildLogs("/some/path", "build-{name}-{stream}-{version}.log")
self.assertEquals(log2.name(build), "build-nginx-1-2.log")
self.assertEquals(log2.path(build), "/some/path/build-nginx-1-2.log")
assert log2.name(build) == "build-nginx-1-2.log"
assert log2.path(build) == "/some/path/build-nginx-1-2.log"

34
tests/test_messaging.py
View File

@@ -21,13 +21,12 @@
# Written by Jakub Kadlcik <jkadlcik@redhat.com>
import unittest
from module_build_service import messaging
from module_build_service.messaging import KojiRepoChange # noqa
from mock import patch, PropertyMock
class TestFedmsgMessaging(unittest.TestCase):
class TestFedmsgMessaging:
def test_buildsys_state_change(self):
# https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -51,8 +50,8 @@ class TestFedmsgMessaging(unittest.TestCase):
msg = messaging.FedmsgMessageParser().parse(buildsys_state_change_msg)
self.assertEqual(msg.build_id, 614503)
self.assertEqual(msg.build_new_state, 1)
assert msg.build_id == 614503
assert msg.build_new_state == 1
@patch("module_build_service.config.Config.system",
new_callable=PropertyMock, return_value="copr")
@@ -80,17 +79,16 @@ class TestFedmsgMessaging(unittest.TestCase):
}
msg = messaging.FedmsgMessageParser().parse(copr_build_end_msg)
self.assertIsInstance(msg, messaging.KojiBuildChange)
self.assertEqual(msg.msg_id, '2013-b05a323d-37ee-4396-9635-7b5dfaf5441b')
self.assertEqual(msg.build_id, 100)
self.assertEqual(msg.task_id, 100)
self.assertEqual(msg.build_new_state, 1)
self.assertEqual(msg.build_name, 'mutt-kz')
self.assertEqual(msg.build_version, '1.5.23.1')
self.assertEqual(msg.build_release, '1.20150203.git.c8504a8a.fc21')
self.assertEqual(msg.state_reason,
('build end: user:fatka copr:mutt-kz build:100 ip:172.16.3.3 '
'pid:12010 status:1'))
assert isinstance(msg, messaging.KojiBuildChange)
assert msg.msg_id == '2013-b05a323d-37ee-4396-9635-7b5dfaf5441b'
assert msg.build_id == 100
assert msg.task_id == 100
assert msg.build_new_state == 1
assert msg.build_name == 'mutt-kz'
assert msg.build_version == '1.5.23.1'
assert msg.build_release == '1.20150203.git.c8504a8a.fc21'
assert msg.state_reason == ('build end: user:fatka copr:mutt-kz build:100 ip:172.16.3.3 '
'pid:12010 status:1')
def test_buildsys_tag(self):
# https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -113,8 +111,8 @@ class TestFedmsgMessaging(unittest.TestCase):
msg = messaging.FedmsgMessageParser().parse(buildsys_tag_msg)
self.assertEqual(msg.tag, "module-debugging-tools-master-20170405115403-build")
self.assertEqual(msg.artifact, "module-build-macros")
assert msg.tag == "module-debugging-tools-master-20170405115403-build"
assert msg.artifact == "module-build-macros"
def test_buildsys_repo_done(self):
# https://fedora-fedmsg.readthedocs.io/en/latest/topics.html#id134
@@ -132,4 +130,4 @@ class TestFedmsgMessaging(unittest.TestCase):
msg = messaging.FedmsgMessageParser().parse(buildsys_tag_msg)
self.assertEqual(msg.repo_tag, "module-f0f7e44f3c6cccab-build")
assert msg.repo_tag == "module-f0f7e44f3c6cccab-build"

21
tests/test_models/test_models.py
View File

@@ -21,7 +21,6 @@
# Written by Ralph Bean <rbean@redhat.com>
import os
import unittest
import modulemd
@@ -30,8 +29,8 @@ from module_build_service import conf
from module_build_service.models import ComponentBuild, ModuleBuild, make_session
class TestModels(unittest.TestCase):
def setUp(self):
class TestModels:
def setup_method(self, test_method):
init_data()
def test_app_sqlalchemy_events(self):
@@ -54,11 +53,11 @@ class TestModels(unittest.TestCase):
with make_session(conf) as session:
c = session.query(ComponentBuild).filter(ComponentBuild.id == 1).one()
self.assertEquals(c.component_builds_trace[0].id, 1)
self.assertEquals(c.component_builds_trace[0].component_id, 1)
self.assertEquals(c.component_builds_trace[0].state, 1)
self.assertEquals(c.component_builds_trace[0].state_reason, None)
self.assertEquals(c.component_builds_trace[0].task_id, 999999999)
assert c.component_builds_trace[0].id == 1
assert c.component_builds_trace[0].component_id == 1
assert c.component_builds_trace[0].state == 1
assert c.component_builds_trace[0].state_reason is None
assert c.component_builds_trace[0].task_id == 999999999
def test_context_functions(self):
""" Test that the build_context, runtime_context, and context hashes are correctly
@@ -70,6 +69,6 @@ class TestModels(unittest.TestCase):
mmd.load(yaml_path)
build.modulemd = mmd.dumps()
build.build_context, build.runtime_context = ModuleBuild.contexts_from_mmd(build.modulemd)
self.assertEqual(build.build_context, 'f6e2aeec7576196241b9afa0b6b22acf2b6873d7')
self.assertEqual(build.runtime_context, '1739827b08388842fc90ccc0b6070c59b7d856fc')
self.assertEqual(build.context, 'e7a3d35e')
assert build.build_context == 'f6e2aeec7576196241b9afa0b6b22acf2b6873d7'
assert build.runtime_context == '1739827b08388842fc90ccc0b6070c59b7d856fc'
assert build.context == 'e7a3d35e'

24
tests/test_resolver/test_pdc.py
View File

@@ -22,7 +22,6 @@
import os
import unittest
from mock import patch, PropertyMock
import vcr
@@ -30,25 +29,24 @@ import module_build_service.resolver as mbs_resolver
import module_build_service.utils
import module_build_service.models
from module_build_service import app, db
from tests import get_vcr_path
import tests
import modulemd
base_dir = os.path.join(os.path.dirname(__file__), "..")
cassette_dir = base_dir + '/vcr-request-data/'
class TestPDCModule(unittest.TestCase):
class TestPDCModule:
def setUp(self):
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
def setup_method(self, test_method):
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
self.resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='pdc')
def tearDown(self):
def teardown_method(self, test_method):
self.vcr.__exit__()
def test_get_variant_dict_module_dict_active(self):
@@ -67,7 +65,7 @@ class TestPDCModule(unittest.TestCase):
}
variant_dict = self.resolver._get_variant_dict(dep)
self.assertEqual(variant_dict, expected)
assert variant_dict == expected
def test_get_module_simple_as_dict(self):
query = {'name': 'testmodule', 'version': 'master'}
@@ -90,7 +88,7 @@ class TestPDCModule(unittest.TestCase):
expected = [
u'module-bootstrap-rawhide',
]
self.assertEqual(set(result), set(expected))
assert set(result) == set(expected)
def test_get_module_build_dependencies_single_level(self):
"""
@@ -107,7 +105,7 @@ class TestPDCModule(unittest.TestCase):
expected = [
u'module-base-runtime-master-20170315134803',
]
self.assertEqual(set(result), set(expected))
assert set(result) == set(expected)
@patch("module_build_service.config.Config.system",
new_callable=PropertyMock, return_value="test")
@@ -138,7 +136,7 @@ class TestPDCModule(unittest.TestCase):
local_path,
'module-parent-master-20170816080815/results'),
]
self.assertEqual(set(result), set(expected))
assert set(result) == set(expected)
def test_resolve_profiles(self):
yaml_path = os.path.join(
@@ -158,7 +156,7 @@ class TestPDCModule(unittest.TestCase):
'fedora-modular-release', 'fedpkg-minimal', 'gnupg2',
'bash'])
}
self.assertEqual(result, expected)
assert result == expected
@patch("module_build_service.config.Config.system",
new_callable=PropertyMock, return_value="test")
@@ -180,4 +178,4 @@ class TestPDCModule(unittest.TestCase):
'srpm-buildroot':
set(['bar'])
}
self.assertEqual(result, expected)
assert result == expected

19
tests/test_scheduler/test_consumer.py
View File

@@ -18,13 +18,12 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import unittest
from mock import patch, MagicMock
from module_build_service.scheduler.consumer import MBSConsumer
from module_build_service.messaging import KojiTagChange, KojiRepoChange
class TestConsumer(unittest.TestCase):
class TestConsumer:
@patch('module_build_service.messaging.conf.messaging', new='fedmsg')
def test_get_abstracted_msg_fedmsg(self):
@@ -57,10 +56,10 @@ class TestConsumer(unittest.TestCase):
}
}
msg_obj = consumer.get_abstracted_msg(msg)
self.assertIsInstance(msg_obj, KojiTagChange)
self.assertEqual(msg_obj.msg_id, msg['msg_id'])
self.assertEqual(msg_obj.tag, msg['msg']['tag'])
self.assertEqual(msg_obj.artifact, msg['msg']['name'])
assert isinstance(msg_obj, KojiTagChange)
assert msg_obj.msg_id == msg['msg_id']
assert msg_obj.tag == msg['msg']['tag']
assert msg_obj.artifact == msg['msg']['name']
@patch('module_build_service.scheduler.consumer.models')
@patch.object(MBSConsumer, 'process_message')
@@ -94,8 +93,8 @@ class TestConsumer(unittest.TestCase):
}
}
consumer.consume(msg)
self.assertEqual(process_message.call_count, 1)
assert process_message.call_count == 1
msg_obj = process_message.call_args[0][1]
self.assertIsInstance(msg_obj, KojiRepoChange)
self.assertEqual(msg_obj.msg_id, msg['body']['msg_id'])
self.assertEqual(msg_obj.repo_tag, msg['body']['msg']['tag'])
assert isinstance(msg_obj, KojiRepoChange)
assert msg_obj.msg_id == msg['body']['msg_id']
assert msg_obj.repo_tag == msg['body']['msg']['tag']

14
tests/test_scheduler/test_module_init.py
View File

@@ -20,24 +20,21 @@
#
import os
import unittest
from mock import patch, PropertyMock
import vcr
from tests import conf, clean_database
from tests import conf, clean_database, get_vcr_path
from tests.test_views.test_views import FakeSCM
import module_build_service.messaging
import module_build_service.scheduler.handlers.modules
from module_build_service import build_logs
from module_build_service.models import make_session, ModuleBuild, ComponentBuild
CASSETTE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'vcr-request-data/')
class TestModuleInit:
class TestModuleInit(unittest.TestCase):
def setUp(self):
def setup_method(self, test_method):
self.fn = module_build_service.scheduler.handlers.modules.init
self.staged_data_dir = os.path.join(
os.path.dirname(__file__), '../', 'staged_data')
@@ -51,11 +48,10 @@ class TestModuleInit(unittest.TestCase):
ModuleBuild.create(
session, conf, 'testmodule', '1', 3, yaml, scmurl, 'mprahl')
filename = os.path.join(CASSETTE_DIR, self.id())
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
self.vcr.__exit__()
try:
path = build_logs.path(1)

23
tests/test_scheduler/test_module_wait.py
View File

@@ -20,7 +20,6 @@
#
# Written by Ralph Bean <rbean@redhat.com>
import unittest
import mock
from mock import patch
import module_build_service.messaging
@@ -29,26 +28,23 @@ import modulemd as _modulemd
import os
import vcr
import koji
from tests import conf, db, app, scheduler_init_data
from tests import conf, db, app, scheduler_init_data, get_vcr_path
from module_build_service import build_logs
from module_build_service.models import ComponentBuild, ModuleBuild
base_dir = os.path.dirname(os.path.dirname(__file__))
cassette_dir = base_dir + '/vcr-request-data/'
class TestModuleWait(unittest.TestCase):
def setUp(self):
class TestModuleWait:
def setup_method(self, test_method):
self.config = conf
self.session = mock.Mock()
self.fn = module_build_service.scheduler.handlers.modules.wait
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
self.vcr.__exit__()
try:
path = build_logs.path(1)
@@ -131,7 +127,7 @@ class TestModuleWait(unittest.TestCase):
# once in database.
builds_count = db.session.query(ComponentBuild).filter_by(
package="module-build-macros", module_id=1).count()
self.assertEqual(builds_count, 1)
assert builds_count == 1
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -167,7 +163,7 @@ class TestModuleWait(unittest.TestCase):
module_build_state='some state')
module_build_service.scheduler.handlers.modules.wait(
config=conf, session=db.session, msg=msg)
self.assertTrue(koji_session.newRepo.called)
assert koji_session.newRepo.called
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -210,7 +206,7 @@ class TestModuleWait(unittest.TestCase):
module_build_service.scheduler.handlers.modules.wait(
config=conf, session=db.session, msg=msg)
module_build = ModuleBuild.query.filter_by(id=1).one()
self.assertEqual(module_build.cg_build_koji_tag, "modular-updates-candidate")
assert module_build.cg_build_koji_tag == "modular-updates-candidate"
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -255,5 +251,4 @@ class TestModuleWait(unittest.TestCase):
module_build_service.scheduler.handlers.modules.wait(
config=conf, session=db.session, msg=msg)
module_build = ModuleBuild.query.filter_by(id=1).one()
self.assertEqual(module_build.cg_build_koji_tag,
"f27-modular-updates-candidate")
assert module_build.cg_build_koji_tag == "f27-modular-updates-candidate"

55
tests/test_scheduler/test_poller.py
View File

@@ -18,7 +18,6 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import unittest
from os import path
from mock import patch
from module_build_service import models, conf
@@ -39,12 +38,12 @@ CASSETTES_DIR = path.join(
@patch("module_build_service.scheduler.consumer.get_global_consumer")
@patch("module_build_service.builder.KojiModuleBuilder.KojiModuleBuilder.get_session")
@patch("module_build_service.builder.GenericBuilder.create_from_module")
class TestPoller(unittest.TestCase):
class TestPoller:
def setUp(self):
def setup_method(self, test_method):
test_reuse_component_init_data()
def tearDown(self):
def teardown_method(self, test_method):
init_data()
@patch('module_build_service.utils.start_build_component')
@@ -82,8 +81,8 @@ class TestPoller(unittest.TestCase):
# Components should be in BUILDING state now.
components = module_build.current_batch()
for component in components:
self.assertEqual(component.state, koji.BUILD_STATES["BUILDING"])
self.assertEqual(len(start_build_component.mock_calls), 2)
assert component.state == koji.BUILD_STATES["BUILDING"]
assert len(start_build_component.mock_calls) == 2
def test_trigger_new_repo_when_failed(self, create_builder,
koji_get_session, global_consumer,
@@ -154,8 +153,8 @@ class TestPoller(unittest.TestCase):
module_build = models.ModuleBuild.query.filter_by(id=2).one()
db.session.refresh(module_build)
self.assertTrue(not koji_session.newRepo.called)
self.assertEqual(module_build.new_repo_task_id, 0)
assert not koji_session.newRepo.called
assert module_build.new_repo_task_id == 0
def test_process_paused_module_builds_waiting_for_repo(
self, create_builder, koji_get_session, global_consumer, dbg):
@@ -192,7 +191,7 @@ class TestPoller(unittest.TestCase):
# Components should not be in building state
components = module_build.current_batch()
for component in components:
self.assertEqual(component.state, None)
assert component.state is None
def test_delete_old_koji_targets(
self, create_builder, koji_get_session, global_consumer, dbg):
@@ -237,7 +236,7 @@ class TestPoller(unittest.TestCase):
# deleteBuildTarget should not be called, because time_completed is
# set to "now".
self.assertTrue(not koji_session.deleteBuildTarget.called)
assert not koji_session.deleteBuildTarget.called
# Try removing non-modular target - should not happen
db.session.refresh(module_build)
@@ -245,7 +244,7 @@ class TestPoller(unittest.TestCase):
module_build.time_completed = datetime.utcnow() - timedelta(hours=25)
db.session.commit()
poller.delete_old_koji_targets(conf, db.session)
self.assertTrue(not koji_session.deleteBuildTarget.called)
assert not koji_session.deleteBuildTarget.called
# Refresh our module_build object and set time_completed 25 hours ago
db.session.refresh(module_build)
@@ -279,15 +278,15 @@ class TestPoller(unittest.TestCase):
db.session.refresh(module_build)
# Ensure the queue is empty before we start.
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
# Poll :)
poller.process_waiting_module_builds(db.session)
self.assertEquals(consumer.incoming.qsize(), 1)
assert consumer.incoming.qsize() == 1
module_build = models.ModuleBuild.query.filter_by(id=2).one()
# ensure the time_modified was changed.
self.assertGreater(module_build.time_modified, original)
assert module_build.time_modified > original
def test_process_waiting_module_build_not_old_enough(self, create_builder, koji_get_session,
global_consumer, dbg):
@@ -310,13 +309,13 @@ class TestPoller(unittest.TestCase):
db.session.refresh(module_build)
# Ensure the queue is empty before we start.
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
# Poll :)
poller.process_waiting_module_builds(db.session)
# Ensure we did *not* process the 9 minute-old build.
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
def test_process_waiting_module_build_none_found(self, create_builder, koji_get_session,
global_consumer, dbg):
@@ -330,13 +329,13 @@ class TestPoller(unittest.TestCase):
poller = MBSProducer(hub)
# Ensure the queue is empty before we start.
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
# Poll :)
poller.process_waiting_module_builds(db.session)
# Ensure we did *not* process any of the non-waiting builds.
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
def test_cleanup_stale_failed_builds(self, create_builder, koji_get_session,
global_consumer, dbg):
@@ -369,20 +368,20 @@ class TestPoller(unittest.TestCase):
poller = MBSProducer(hub)
# Ensure the queue is empty before we start
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
poller.cleanup_stale_failed_builds(conf, db.session)
db.session.refresh(module_build_two)
# Make sure module_build_one was transitioned to garbage
self.assertEqual(module_build_one.state, models.BUILD_STATES['garbage'])
assert module_build_one.state == models.BUILD_STATES['garbage']
state_reason = ('The module was garbage collected since it has failed over {0} day(s) ago'
.format(conf.cleanup_failed_builds_time))
self.assertEqual(module_build_one.state_reason, state_reason)
assert module_build_one.state_reason == state_reason
# Make sure all the components are marked as untagged in the database
for component in module_build_one.component_builds:
self.assertFalse(component.tagged)
self.assertFalse(component.tagged_in_final)
assert not component.tagged
assert not component.tagged_in_final
# Make sure module_build_two stayed the same
self.assertEqual(module_build_two.state, models.BUILD_STATES['failed'])
assert module_build_two.state == models.BUILD_STATES['failed']
# Make sure the builds were untagged
builder.untag_artifacts.assert_called_once_with([
'perl-Tangerine-0.23-1.module+0+814cfa39',
@@ -419,15 +418,15 @@ class TestPoller(unittest.TestCase):
poller = MBSProducer(hub)
# Ensure the queue is empty before we start
self.assertEquals(consumer.incoming.qsize(), 0)
assert consumer.incoming.qsize() == 0
poller.cleanup_stale_failed_builds(conf, db.session)
db.session.refresh(module_build_two)
# Make sure module_build_two was transitioned to garbage
self.assertEqual(module_build_two.state, models.BUILD_STATES['garbage'])
assert module_build_two.state == models.BUILD_STATES['garbage']
state_reason = ('The module was garbage collected since it has failed over {0} day(s) ago'
.format(conf.cleanup_failed_builds_time))
self.assertEqual(module_build_two.state_reason, state_reason)
assert module_build_two.state_reason == state_reason
# Make sure module_build_one stayed the same
self.assertEqual(module_build_one.state, models.BUILD_STATES['failed'])
assert module_build_one.state == models.BUILD_STATES['failed']
# Make sure that the builder was never instantiated
create_builder.assert_not_called()

22
tests/test_scheduler/test_repo_done.py
View File

@@ -21,30 +21,26 @@
# Written by Ralph Bean <rbean@redhat.com>
from os.path import dirname
import unittest
import mock
import vcr
import module_build_service.messaging
import module_build_service.scheduler.handlers.repos
import module_build_service.models
from tests import scheduler_init_data
from tests import conf, db, app
from tests import conf, db, app, scheduler_init_data, get_vcr_path
base_dir = dirname(dirname(__file__))
cassette_dir = base_dir + '/vcr-request-data/'
class TestRepoDone(unittest.TestCase):
class TestRepoDone:
def setUp(self):
def setup_method(self, test_method):
scheduler_init_data()
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
self.vcr = vcr.use_cassette(get_vcr_path(__file__, test_method))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
self.vcr.__exit__()
@mock.patch('module_build_service.models.ModuleBuild.from_repo_done_event')
@@ -124,8 +120,7 @@ class TestRepoDone(unittest.TestCase):
'?#da95886c8a443b36a9ce31abda1f9bed22f2f9c2'))
component_build = module_build_service.models.ComponentBuild.query\
.filter_by(package='communicator').one()
self.assertEquals(component_build.state_reason,
'Failed to submit artifact communicator to Koji')
assert component_build.state_reason == 'Failed to submit artifact communicator to Koji'
@mock.patch('module_build_service.scheduler.handlers.repos.log.info')
def test_erroneous_regen_repo_received(self, mock_log_info):
@@ -146,7 +141,7 @@ class TestRepoDone(unittest.TestCase):
'Ignoring repo regen, because not all components are tagged.')
module_build = module_build_service.models.ModuleBuild.query.get(1)
# Make sure the module build didn't transition since all the components weren't tagged
self.assertEqual(module_build.state, module_build_service.models.BUILD_STATES['build'])
assert module_build.state == module_build_service.models.BUILD_STATES['build']
@mock.patch('module_build_service.builder.KojiModuleBuilder.'
'KojiModuleBuilder.list_tasks_for_components',
@@ -177,5 +172,4 @@ class TestRepoDone(unittest.TestCase):
module_build = module_build_service.models.ModuleBuild.query\
.filter_by(name='starcommand').one()
self.assertEquals(module_build.state,
module_build_service.models.BUILD_STATES["failed"])
assert module_build.state == module_build_service.models.BUILD_STATES["failed"]

28
tests/test_scheduler/test_tag_tagged.py
View File

@@ -20,7 +20,6 @@
#
# Written by Jan Kaluza <jkaluza@redhat.com>
import unittest
import mock
from mock import patch
@@ -34,14 +33,11 @@ from tests import conf, db
import koji
class TestTagTagged(unittest.TestCase):
class TestTagTagged:
def setUp(self):
def setup_method(self, test_method):
test_reuse_component_init_data()
def tearDown(self):
pass
@mock.patch('module_build_service.models.ModuleBuild.from_tag_change_event')
def test_no_matching_module(self, from_tag_change_event):
""" Test that when a tag msg hits us and we have no match,
@@ -109,7 +105,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo should not be called, because there are still components
# to tag.
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
# Tag the second component to the buildroot.
msg = module_build_service.messaging.KojiTagChange(
@@ -119,7 +115,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo should not be called, because the component has not been
# tagged to final tag so far.
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
# Tag the first component to the final tag.
msg = module_build_service.messaging.KojiTagChange(
@@ -136,7 +132,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo task_id should be stored in database, so we can check its
# status later in poller.
self.assertEqual(module_build.new_repo_task_id, 123456)
assert module_build.new_repo_task_id == 123456
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -178,7 +174,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo should not be called, because perl-List-Compare has not been
# built yet.
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -239,7 +235,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo task_id should be stored in database, so we can check its
# status later in poller.
self.assertEqual(module_build.new_repo_task_id, 123456)
assert module_build.new_repo_task_id == 123456
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -287,7 +283,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo should not be called, because there are still components
# to tag.
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
# Tag the second component to the buildroot.
msg = module_build_service.messaging.KojiTagChange(
@@ -302,7 +298,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo should not be called, because there are still components
# to tag.
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
# Tag the component from first batch to final tag.
msg = module_build_service.messaging.KojiTagChange(
@@ -324,7 +320,7 @@ class TestTagTagged(unittest.TestCase):
# newRepo task_id should be stored in database, so we can check its
# status later in poller.
self.assertEqual(module_build.new_repo_task_id, 123456)
assert module_build.new_repo_task_id == 123456
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
@@ -373,7 +369,7 @@ class TestTagTagged(unittest.TestCase):
'id', 'module-testmodule-build', "perl-Tangerine")
module_build_service.scheduler.handlers.tags.tagged(
config=conf, session=db.session, msg=msg)
self.assertTrue(not koji_session.newRepo.called)
assert not koji_session.newRepo.called
# Tag the perl-List-Compare component to the buildroot.
msg = module_build_service.messaging.KojiTagChange(
'id', 'module-testmodule-build', "perl-List-Compare")
@@ -395,4 +391,4 @@ class TestTagTagged(unittest.TestCase):
# newRepo task_id should be stored in database, so we can check its
# status later in poller.
self.assertEqual(module_build.new_repo_task_id, 123456)
assert module_build.new_repo_task_id == 123456

9
tests/test_scm.py
View File

@@ -24,7 +24,6 @@ import os
import shutil
import tempfile
import unittest
from mock import patch
from nose.tools import raises
@@ -34,13 +33,13 @@ from module_build_service.errors import ValidationError, UnprocessableEntity
repo_path = 'file://' + os.path.dirname(__file__) + "/scm_data/testrepo"
class TestSCMModule(unittest.TestCase):
class TestSCMModule:
def setUp(self):
def setup_method(self, test_method):
self.tempdir = tempfile.mkdtemp()
self.repodir = self.tempdir + '/testrepo'
def tearDown(self):
def teardown_method(self, test_method):
if os.path.exists(self.tempdir):
shutil.rmtree(self.tempdir)
@@ -152,4 +151,4 @@ class TestSCMModule(unittest.TestCase):
mock_run.return_value = (0, output, '')
scm = module_build_service.scm.SCM(repo_path)
commit = scm.get_latest(None)
self.assertEquals(commit, '58379ef7887cbc91b215bacd32430628c92bc869')
assert commit == '58379ef7887cbc91b215bacd32430628c92bc869'

219
tests/test_utils/test_utils.py
View File

@@ -18,7 +18,6 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import unittest
import tempfile
from os import path, mkdir
from shutil import copyfile, rmtree
@@ -36,6 +35,7 @@ from tests import (test_reuse_component_init_data, init_data, db,
clean_database)
import mock
import koji
import pytest
import module_build_service.scheduler.handlers.components
from module_build_service.builder.base import GenericBuilder
from module_build_service.builder.KojiModuleBuilder import KojiModuleBuilder
@@ -79,10 +79,9 @@ class FakeSCM(object):
return path.join(self.sourcedir, self.name + ".yaml")
class TestUtils(unittest.TestCase):
maxDiff = None
class TestUtils:
def setUp(self):
def setup_method(self, test_method):
self.filtered_rpms = [
u'sqlite-tcl-0:3.17.0-2.module_5ccf9229',
u'sqlite-analyzer-0:3.17.0-2.module_5ccf9229',
@@ -229,7 +228,7 @@ class TestUtils(unittest.TestCase):
u'iproute-tc-0:4.11.0-1.module_d6de39f1'
]
def tearDown(self):
def teardown_method(self, test_method):
init_data()
@vcr.use_cassette(
@@ -260,9 +259,9 @@ class TestUtils(unittest.TestCase):
# Make sure that original refs are not changed.
mmd_pkg_refs = [pkg.ref for pkg in mmd.components.rpms.values()]
self.assertEqual(set(mmd_pkg_refs), set(original_refs))
assert set(mmd_pkg_refs) == set(original_refs)
self.assertEqual(mmd.buildrequires, {'base-runtime': 'master'})
assert mmd.buildrequires == {'base-runtime': 'master'}
xmd = {
'mbs': {
'commit': '620ec77321b2ea7b0d67d82992dda3e1d67055b4',
@@ -286,7 +285,7 @@ class TestUtils(unittest.TestCase):
}
}
self.assertEqual(mmd.xmd, xmd)
assert mmd.xmd == xmd
@vcr.use_cassette(
path.join(CASSETTES_DIR, 'tests.test_utils.TestUtils.test_format_mmd'))
@@ -329,14 +328,14 @@ class TestUtils(unittest.TestCase):
'scmurl': None,
}
}
self.assertEqual(mmd.xmd, xmd)
assert mmd.xmd == xmd
def test_get_reusable_component_same(self):
test_reuse_component_init_data()
new_module = models.ModuleBuild.query.filter_by(id=2).one()
rv = module_build_service.utils.get_reusable_component(
db.session, new_module, 'tangerine')
self.assertEqual(rv.package, 'tangerine')
assert rv.package == 'tangerine'
def test_get_reusable_component_different_perl_tangerine(self):
test_reuse_component_init_data()
@@ -355,18 +354,18 @@ class TestUtils(unittest.TestCase):
# none)
plc_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-List-Compare')
self.assertEqual(plc_rv.package, 'perl-List-Compare')
assert plc_rv.package == 'perl-List-Compare'
# perl-Tangerine has a different commit hash
pt_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-Tangerine')
self.assertEqual(pt_rv, None)
assert pt_rv is None
# tangerine is the same but its in a build order that is after the
# different perl-Tangerine, so it can't be reused
tangerine_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'tangerine')
self.assertEqual(tangerine_rv, None)
assert tangerine_rv is None
def test_get_reusable_component_different_rpm_macros(self):
test_reuse_component_init_data()
@@ -378,12 +377,12 @@ class TestUtils(unittest.TestCase):
plc_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-List-Compare')
self.assertEqual(plc_rv, None)
assert plc_rv is None
# perl-Tangerine has a different commit hash
pt_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-Tangerine')
self.assertEqual(pt_rv, None)
assert pt_rv is None
def test_get_reusable_component_different_buildrequires_hash(self):
test_reuse_component_init_data()
@@ -397,18 +396,18 @@ class TestUtils(unittest.TestCase):
plc_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-List-Compare')
self.assertEqual(plc_rv, None)
assert plc_rv is None
# perl-Tangerine has a different commit hash
pt_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-Tangerine')
self.assertEqual(pt_rv, None)
assert pt_rv is None
# tangerine is the same but its in a build order that is after the
# different perl-Tangerine, so it can't be reused
tangerine_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'tangerine')
self.assertEqual(tangerine_rv, None)
assert tangerine_rv is None
def test_get_reusable_component_different_buildrequires(self):
test_reuse_component_init_data()
@@ -428,18 +427,18 @@ class TestUtils(unittest.TestCase):
plc_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-List-Compare')
self.assertEqual(plc_rv, None)
assert plc_rv is None
# perl-Tangerine has a different commit hash
pt_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'perl-Tangerine')
self.assertEqual(pt_rv, None)
assert pt_rv is None
# tangerine is the same but its in a build order that is after the
# different perl-Tangerine, so it can't be reused
tangerine_rv = module_build_service.utils.get_reusable_component(
db.session, second_module_build, 'tangerine')
self.assertEqual(tangerine_rv, None)
assert tangerine_rv is None
def test_get_reusable_component_shared_userspace_ordering(self):
"""
@@ -452,7 +451,7 @@ class TestUtils(unittest.TestCase):
new_module = models.ModuleBuild.query.filter_by(id=2).one()
rv = module_build_service.utils.get_reusable_component(
db.session, new_module, 'llvm')
self.assertEqual(rv.package, 'llvm')
assert rv.package == 'llvm'
def test_validate_koji_tag_wrong_tag_arg_during_programming(self):
""" Test that we fail on a wrong param name (non-existing one) due to
@@ -462,7 +461,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_programming_error(good_tag_arg, other_arg):
pass
with self.assertRaises(ProgrammingError):
with pytest.raises(ProgrammingError):
validate_koji_tag_programming_error('dummy', 'other_val')
def test_validate_koji_tag_bad_tag_value(self):
@@ -472,7 +471,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_bad_tag_value(tag_arg):
pass
with self.assertRaises(ValidationError):
with pytest.raises(ValidationError):
validate_koji_tag_bad_tag_value('forbiddentagprefix-foo')
def test_validate_koji_tag_bad_tag_value_in_list(self):
@@ -482,7 +481,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_bad_tag_value_in_list(tag_arg):
pass
with self.assertRaises(ValidationError):
with pytest.raises(ValidationError):
validate_koji_tag_bad_tag_value_in_list([
'module-foo', 'forbiddentagprefix-bar'])
@@ -493,8 +492,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_good_tag_value(tag_arg):
return True
self.assertEquals(
validate_koji_tag_good_tag_value('module-foo'), True)
assert validate_koji_tag_good_tag_value('module-foo') is True
def test_validate_koji_tag_good_tag_values_in_list(self):
""" Test that we pass on a list of good tag values. """
@@ -503,9 +501,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_good_tag_values_in_list(tag_arg):
return True
self.assertEquals(
validate_koji_tag_good_tag_values_in_list(['module-foo',
'module-bar']), True)
assert validate_koji_tag_good_tag_values_in_list(['module-foo', 'module-bar']) is True
def test_validate_koji_tag_good_tag_value_in_dict(self):
""" Test that we pass on a dict arg with default key
@@ -515,8 +511,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_good_tag_value_in_dict(tag_arg):
return True
self.assertEquals(
validate_koji_tag_good_tag_value_in_dict({'name': 'module-foo'}), True)
assert validate_koji_tag_good_tag_value_in_dict({'name': 'module-foo'}) is True
def test_validate_koji_tag_good_tag_value_in_dict_nondefault_key(self):
""" Test that we pass on a dict arg with non-default key
@@ -527,9 +522,8 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_good_tag_value_in_dict_nondefault_key(tag_arg):
return True
self.assertEquals(
validate_koji_tag_good_tag_value_in_dict_nondefault_key(
{'nondefault': 'module-foo'}), True)
assert validate_koji_tag_good_tag_value_in_dict_nondefault_key(
{'nondefault': 'module-foo'}) is True
def test_validate_koji_tag_double_trouble_good(self):
""" Test that we pass on a list of tags that are good. """
@@ -541,7 +535,7 @@ class TestUtils(unittest.TestCase):
return expected
actual = validate_koji_tag_double_trouble('module-1', 'module-2')
self.assertEquals(actual, expected)
assert actual == expected
def test_validate_koji_tag_double_trouble_bad(self):
""" Test that we fail on a list of tags that are bad. """
@@ -550,7 +544,7 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_double_trouble(tag_arg1, tag_arg2):
pass
with self.assertRaises(ValidationError):
with pytest.raises(ValidationError):
validate_koji_tag_double_trouble('module-1', 'BADNEWS-2')
def test_validate_koji_tag_is_None(self):
@@ -560,10 +554,9 @@ class TestUtils(unittest.TestCase):
def validate_koji_tag_is_None(tag_arg):
pass
with self.assertRaises(ValidationError) as cm:
with pytest.raises(ValidationError) as cm:
validate_koji_tag_is_None(None)
self.assertTrue(str(cm.exception).endswith(' No value provided.'))
assert str(cm.value).endswith(' No value provided.') is True
@vcr.use_cassette(
path.join(CASSETTES_DIR, 'tests.test_utils.TestUtils.test_format_mmd'))
@@ -611,13 +604,13 @@ class TestUtils(unittest.TestCase):
"Tom Brady", 'git://pkgs.stg.fedoraproject.org/modules/testmodule.git?#8fea453',
'master')
self.assertEqual(module_build.state, models.BUILD_STATES['wait'])
self.assertEqual(module_build.batch, 0)
self.assertEqual(module_build.state_reason, "Resubmitted by Tom Brady")
self.assertEqual(complete_component.state, koji.BUILD_STATES['COMPLETE'])
assert module_build.state == models.BUILD_STATES['wait']
assert module_build.batch == 0
assert module_build.state_reason == "Resubmitted by Tom Brady"
assert complete_component.state == koji.BUILD_STATES['COMPLETE']
# The failed/cancelled components are now stateless
self.assertIsNone(failed_component.state)
self.assertIsNone(canceled_component.state)
assert failed_component.state is None
assert canceled_component.state is None
@vcr.use_cassette(
path.join(CASSETTES_DIR, ('tests.test_utils.TestUtils.'
@@ -651,12 +644,10 @@ class TestUtils(unittest.TestCase):
error_msg = (
'The included module "testmodule-variant" in "testmodule" have '
'the following conflicting components: perl-List-Compare')
try:
with pytest.raises(UnprocessableEntity) as e:
module_build_service.utils.record_component_builds(
testmodule_variant_mmd, module_build, main_mmd=mmd)
assert False, 'A UnprocessableEntity was expected but was not raised'
except UnprocessableEntity as e:
self.assertEqual(e.message, error_msg)
assert str(e.value) == error_msg
@patch("module_build_service.utils.submit_module_build")
def test_submit_module_build_from_yaml_with_skiptests(self, mock_submit):
@@ -725,10 +716,10 @@ class TestUtils(unittest.TestCase):
module_build_service.utils.record_component_builds(
mmd, module_build)
self.assertEqual(module_build.state, models.BUILD_STATES['init'])
assert module_build.state == models.BUILD_STATES['init']
db.session.refresh(module_build)
for c in module_build.component_builds:
self.assertEqual(c.weight, 1.5)
assert c.weight == 1.5
class DummyModuleBuilder(GenericBuilder):
@@ -798,13 +789,13 @@ class DummyModuleBuilder(GenericBuilder):
@patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",
return_value={'build': [], 'srpm-build': []})
class TestBatches(unittest.TestCase):
class TestBatches:
def setUp(self):
def setup_method(self, test_method):
test_reuse_component_init_data()
GenericBuilder.register_backend_class(DummyModuleBuilder)
def tearDown(self):
def teardown_method(self, test_method):
init_data()
DummyModuleBuilder.TAGGED_COMPONENTS = []
GenericBuilder.register_backend_class(KojiModuleBuilder)
@@ -827,7 +818,7 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should increase.
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# KojiBuildChange messages in further_work should have build_new_state
# set to COMPLETE, but the current component build state should be set
@@ -835,9 +826,9 @@ class TestBatches(unittest.TestCase):
# properly.
for msg in further_work:
if type(msg) == module_build_service.messaging.KojiBuildChange:
self.assertEqual(msg.build_new_state, koji.BUILD_STATES['COMPLETE'])
assert msg.build_new_state == koji.BUILD_STATES['COMPLETE']
component_build = models.ComponentBuild.from_component_event(db.session, msg)
self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
assert component_build.state == koji.BUILD_STATES['BUILDING']
# When we handle these KojiBuildChange messages, MBS should tag all
# the components just once.
@@ -848,10 +839,10 @@ class TestBatches(unittest.TestCase):
# Since we have reused all the components in the batch, there should
# be fake KojiRepoChange message.
self.assertEqual(type(further_work[-1]), module_build_service.messaging.KojiRepoChange)
assert type(further_work[-1]) == module_build_service.messaging.KojiRepoChange
# Check that packages have been tagged just once.
self.assertEqual(len(DummyModuleBuilder.TAGGED_COMPONENTS), 2)
assert len(DummyModuleBuilder.TAGGED_COMPONENTS) == 2
@patch('module_build_service.utils.start_build_component')
def test_start_next_batch_build_reuse_some(self, mock_sbc, default_buildroot_groups):
@@ -876,22 +867,22 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should increase.
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# Make sure we only have one message returned for the one reused component
self.assertEqual(len(further_work), 1)
assert len(further_work) == 1
# The KojiBuildChange message in further_work should have build_new_state
# set to COMPLETE, but the current component build state in the DB should be set
# to BUILDING, so KojiBuildChange message handler handles the change
# properly.
self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
self.assertEqual(component_build.package, 'perl-Tangerine')
self.assertIsNotNone(component_build.reused_component_id)
assert component_build.state == koji.BUILD_STATES['BUILDING']
assert component_build.package == 'perl-Tangerine'
assert component_build.reused_component_id is not None
# Make sure perl-List-Compare is set to the build state as well but not reused
self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
self.assertIsNone(plc_component.reused_component_id)
assert plc_component.state == koji.BUILD_STATES['BUILDING']
assert plc_component.reused_component_id is None
mock_sbc.assert_called_once()
@patch('module_build_service.utils.start_build_component')
@@ -913,11 +904,11 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should increase.
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# No component reuse messages should be returned
self.assertEqual(len(further_work), 0)
assert len(further_work) == 0
# Make sure that both components in the batch were submitted
self.assertEqual(len(mock_sbc.mock_calls), 2)
assert len(mock_sbc.mock_calls) == 2
@patch('module_build_service.utils.start_build_component')
@patch('module_build_service.config.Config.rebuild_strategy',
@@ -944,22 +935,22 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should increase
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# Make sure we only have one message returned for the one reused component
self.assertEqual(len(further_work), 1)
assert len(further_work) == 1
# The KojiBuildChange message in further_work should have build_new_state
# set to COMPLETE, but the current component build state in the DB should be set
# to BUILDING, so KojiBuildChange message handler handles the change
# properly.
self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
self.assertEqual(component_build.package, 'perl-Tangerine')
self.assertIsNotNone(component_build.reused_component_id)
assert component_build.state == koji.BUILD_STATES['BUILDING']
assert component_build.package == 'perl-Tangerine'
assert component_build.reused_component_id is not None
# Make sure perl-List-Compare is set to the build state as well but not reused
self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
self.assertIsNone(plc_component.reused_component_id)
assert plc_component.state == koji.BUILD_STATES['BUILDING']
assert plc_component.reused_component_id is None
mock_sbc.assert_called_once()
mock_sbc.reset_mock()
@@ -973,14 +964,14 @@ class TestBatches(unittest.TestCase):
further_work = module_build_service.utils.start_next_batch_build(
conf, module_build, db.session, builder)
# Batch number should increase
self.assertEqual(module_build.batch, 3)
assert module_build.batch == 3
# Verify that tangerine was reused even though perl-Tangerine was rebuilt in the previous
# batch
self.assertEqual(further_work[0].build_new_state, koji.BUILD_STATES['COMPLETE'])
assert further_work[0].build_new_state == koji.BUILD_STATES['COMPLETE']
component_build = models.ComponentBuild.from_component_event(db.session, further_work[0])
self.assertEqual(component_build.state, koji.BUILD_STATES['BUILDING'])
self.assertEqual(component_build.package, 'tangerine')
self.assertIsNotNone(component_build.reused_component_id)
assert component_build.state == koji.BUILD_STATES['BUILDING']
assert component_build.package == 'tangerine'
assert component_build.reused_component_id is not None
mock_sbc.assert_not_called()
@patch('module_build_service.utils.start_build_component')
@@ -1008,18 +999,18 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should increase.
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# Make sure we don't have any messages returned since no components should be reused
self.assertEqual(len(further_work), 0)
assert len(further_work) == 0
# Make sure both components are set to the build state but not reused
self.assertEqual(pt_component.state, koji.BUILD_STATES['BUILDING'])
self.assertIsNone(pt_component.reused_component_id)
self.assertEqual(plc_component.state, koji.BUILD_STATES['BUILDING'])
self.assertIsNone(plc_component.reused_component_id)
assert pt_component.state == koji.BUILD_STATES['BUILDING']
assert pt_component.reused_component_id is None
assert plc_component.state == koji.BUILD_STATES['BUILDING']
assert plc_component.reused_component_id is None
# Test the order of the scheduling
expected_calls = [mock.call(builder, plc_component), mock.call(builder, pt_component)]
self.assertEqual(mock_sbc.mock_calls, expected_calls)
assert mock_sbc.mock_calls == expected_calls
@patch('module_build_service.utils.start_build_component')
def test_start_next_batch_continue(self, mock_sbc, default_buildroot_groups):
@@ -1041,11 +1032,11 @@ class TestBatches(unittest.TestCase):
conf, module_build, db.session, builder)
# Batch number should not increase.
self.assertEqual(module_build.batch, 2)
assert module_build.batch == 2
# Make sure start build was called for the second component which wasn't reused
mock_sbc.assert_called_once()
# No further work should be returned
self.assertEqual(len(further_work), 0)
assert len(further_work) == 0
def test_start_next_batch_build_repo_building(self, default_buildroot_groups):
"""
@@ -1059,7 +1050,7 @@ class TestBatches(unittest.TestCase):
builder.buildroot_ready.return_value = False
# Batch number should not increase.
self.assertEqual(module_build.batch, 1)
assert module_build.batch == 1
@patch("module_build_service.config.Config.mock_resultsdir",
@@ -1068,12 +1059,12 @@ class TestBatches(unittest.TestCase):
BASE_DIR, '..', 'staged_data', "local_builds"))
@patch("module_build_service.config.Config.system",
new_callable=mock.PropertyMock, return_value="mock")
class TestLocalBuilds(unittest.TestCase):
class TestLocalBuilds:
def setUp(self):
def setup_method(self):
init_data()
def tearDown(self):
def teardown_method(self):
init_data()
def test_load_local_builds_name(self, conf_system, conf_resultsdir):
@@ -1081,9 +1072,9 @@ class TestLocalBuilds(unittest.TestCase):
module_build_service.utils.load_local_builds("testmodule")
local_modules = models.ModuleBuild.local_modules(db.session)
self.assertEqual(len(local_modules), 1)
self.assertTrue(local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080816/results"))
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080816/results")
def test_load_local_builds_name_stream(
self, conf_system, conf_resultsdir):
@@ -1091,14 +1082,14 @@ class TestLocalBuilds(unittest.TestCase):
module_build_service.utils.load_local_builds("testmodule:master")
local_modules = models.ModuleBuild.local_modules(db.session)
self.assertEqual(len(local_modules), 1)
self.assertTrue(local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080816/results"))
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080816/results")
def test_load_local_builds_name_stream_non_existing(
self, conf_system, conf_resultsdir):
with app.app_context():
with self.assertRaises(RuntimeError):
with pytest.raises(RuntimeError):
module_build_service.utils.load_local_builds("testmodule:x")
models.ModuleBuild.local_modules(db.session)
@@ -1108,14 +1099,14 @@ class TestLocalBuilds(unittest.TestCase):
module_build_service.utils.load_local_builds("testmodule:master:20170816080815")
local_modules = models.ModuleBuild.local_modules(db.session)
self.assertEqual(len(local_modules), 1)
self.assertTrue(local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080815/results"))
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080815/results")
def test_load_local_builds_name_stream_version_non_existing(
self, conf_system, conf_resultsdir):
with app.app_context():
with self.assertRaises(RuntimeError):
with pytest.raises(RuntimeError):
module_build_service.utils.load_local_builds("testmodule:master:123")
models.ModuleBuild.local_modules(db.session)
@@ -1125,9 +1116,9 @@ class TestLocalBuilds(unittest.TestCase):
module_build_service.utils.load_local_builds("base-runtime")
local_modules = models.ModuleBuild.local_modules(db.session)
self.assertEqual(len(local_modules), 1)
self.assertTrue(local_modules[0].koji_tag.endswith(
"/module-base-runtime-master-20170816080815/results"))
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-base-runtime-master-20170816080815/results")
def test_load_local_builds_base_runtime_master(
self, conf_system, conf_resultsdir):
@@ -1135,6 +1126,6 @@ class TestLocalBuilds(unittest.TestCase):
module_build_service.utils.load_local_builds("base-runtime:master")
local_modules = models.ModuleBuild.local_modules(db.session)
self.assertEqual(len(local_modules), 1)
self.assertTrue(local_modules[0].koji_tag.endswith(
"/module-base-runtime-master-20170816080815/results"))
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-base-runtime-master-20170816080815/results")

496
tests/test_views/test_views.py
View File

@@ -18,9 +18,8 @@
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Written by Matt Prahl <mprahl@redhat.com
# Written by Matt Prahl <mprahl@redhat.com>
import unittest
import json
import vcr
@@ -112,31 +111,32 @@ class FakeSCM(object):
return path.join(self.sourcedir, self.name + ".yaml")
class TestViews(unittest.TestCase):
maxDiff = None
def setUp(self):
class TestViews:
def setup_method(self, test_method):
self.client = app.test_client()
init_data()
filename = cassette_dir + self.id()
self.vcr = vcr.use_cassette(filename)
filename = '.'.join([
path.splitext(path.basename(__file__))[0],
test_method.im_class.__name__,
test_method.im_func.__name__])
self.vcr = vcr.use_cassette(path.join(cassette_dir, filename))
self.vcr.__enter__()
def tearDown(self):
def teardown_method(self, test_method):
self.vcr.__exit__()
def test_query_build(self):
rv = self.client.get('/module-build-service/1/module-builds/1')
data = json.loads(rv.data)
self.assertEquals(data['id'], 1)
self.assertEquals(data['context'], '00000000')
self.assertEquals(data['name'], 'nginx')
self.assertEquals(data['owner'], 'Moe Szyslak')
self.assertEquals(data['stream'], '1')
self.assertEquals(data['state'], 3)
self.assertEquals(data['state_reason'], None)
self.assertDictEqual(data['tasks'], {
assert data['id'] == 1
assert data['context'] == '00000000'
assert data['name'] == 'nginx'
assert data['owner'] == 'Moe Szyslak'
assert data['stream'] == '1'
assert data['state'] == 3
assert data['state_reason'] is None
assert data['tasks'] == {
'rpms': {
'module-build-macros': {
'task_id': 12312321,
@@ -151,49 +151,48 @@ class TestViews(unittest.TestCase):
'nvr': 'nginx-1.10.1-2.module+1+b8661ee4',
},
},
})
self.assertEquals(data['time_completed'], '2016-09-03T11:25:32Z')
self.assertEquals(data['time_modified'], '2016-09-03T11:25:32Z')
self.assertEquals(data['time_submitted'], '2016-09-03T11:23:20Z')
self.assertEqual(data['rebuild_strategy'], 'changed-and-after')
self.assertEquals(data['version'], '2')
}
assert data['time_completed'] == '2016-09-03T11:25:32Z'
assert data['time_modified'] == '2016-09-03T11:25:32Z'
assert data['time_submitted'] == '2016-09-03T11:23:20Z'
assert data['rebuild_strategy'] == 'changed-and-after'
assert data['version'] == '2'
def test_query_build_short(self):
rv = self.client.get('/module-build-service/1/module-builds/1?short=True')
data = json.loads(rv.data)
self.assertEquals(data['id'], 1)
self.assertEquals(data['context'], '00000000')
self.assertEquals(data['name'], 'nginx')
self.assertEquals(data['state'], 3)
self.assertEquals(data['state_name'], 'done')
self.assertEquals(data['stream'], '1')
self.assertEquals(data['version'], '2')
assert data['id'] == 1
assert data['context'] == '00000000'
assert data['name'] == 'nginx'
assert data['state'] == 3
assert data['state_name'] == 'done'
assert data['stream'] == '1'
assert data['version'] == '2'
def test_query_build_with_verbose_mode(self):
rv = self.client.get('/module-build-service/1/module-builds/1?verbose=true')
data = json.loads(rv.data)
self.assertEquals(data['component_builds'], [1, 2])
self.assertEquals(data['context'], '00000000')
assert data['component_builds'] == [1, 2]
assert data['context'] == '00000000'
# There is no xmd information on this module, so these values should be null
self.assertIsNone(data['build_context'])
self.assertIsNone(data['runtime_context'])
self.assertEquals(data['id'], 1)
assert data['build_context'] is None
assert data['runtime_context'] is None
assert data['id'] == 1
with open(path.join(base_dir, "staged_data", "nginx_mmd.yaml")) as mmd:
self.assertEquals(data['modulemd'], mmd.read())
self.assertEquals(data['name'], 'nginx')
self.assertEquals(data['owner'], 'Moe Szyslak')
self.assertEquals(data['scmurl'],
('git://pkgs.domain.local/modules/nginx'
'?#ba95886c7a443b36a9ce31abda1f9bef22f2f8c9'))
self.assertEquals(data['state'], 3)
self.assertEquals(data['state_name'], 'done')
self.assertEquals(data['state_reason'], None)
assert data['modulemd'] == mmd.read()
assert data['name'] == 'nginx'
assert data['owner'] == 'Moe Szyslak'
assert data['scmurl'] == ('git://pkgs.domain.local/modules/nginx'
'?#ba95886c7a443b36a9ce31abda1f9bef22f2f8c9')
assert data['state'] == 3
assert data['state_name'] == 'done'
assert data['state_reason'] is None
# State trace is empty because we directly created these builds and didn't have them
# transition, which creates these entries
self.assertEquals(data['state_trace'], [])
self.assertEquals(data['state_url'], '/module-build-service/1/module-builds/1')
self.assertEquals(data['stream'], '1')
self.assertDictEqual(data['tasks'], {
assert data['state_trace'] == []
assert data['state_url'] == '/module-build-service/1/module-builds/1'
assert data['stream'] == '1'
assert data['tasks'] == {
'rpms': {
'module-build-macros': {
'task_id': 12312321,
@@ -208,39 +207,35 @@ class TestViews(unittest.TestCase):
'nvr': 'nginx-1.10.1-2.module+1+b8661ee4',
},
},
})
self.assertEquals(data['time_completed'], u'2016-09-03T11:25:32Z')
self.assertEquals(data['time_modified'], u'2016-09-03T11:25:32Z')
self.assertEquals(data['time_submitted'], u'2016-09-03T11:23:20Z')
self.assertEquals(data['version'], '2')
self.assertEqual(data['rebuild_strategy'], 'changed-and-after')
}
assert data['time_completed'] == u'2016-09-03T11:25:32Z'
assert data['time_modified'] == u'2016-09-03T11:25:32Z'
assert data['time_submitted'] == u'2016-09-03T11:23:20Z'
assert data['version'] == '2'
assert data['rebuild_strategy'] == 'changed-and-after'
def test_pagination_metadata(self):
rv = self.client.get('/module-build-service/1/module-builds/?per_page=8&page=2')
meta_data = json.loads(rv.data)['meta']
self.assertIn(
meta_data['prev'].split('?', 1)[1], ['per_page=8&page=1', 'page=1&per_page=8'])
self.assertIn(
meta_data['next'].split('?', 1)[1], ['per_page=8&page=3', 'page=3&per_page=8'])
self.assertIn(
meta_data['last'].split('?', 1)[1], ['per_page=8&page=4', 'page=4&per_page=8'])
self.assertIn(
meta_data['first'].split('?', 1)[1], ['per_page=8&page=1', 'page=1&per_page=8'])
self.assertEquals(meta_data['total'], 30)
self.assertEquals(meta_data['per_page'], 8)
self.assertEquals(meta_data['pages'], 4)
self.assertEquals(meta_data['page'], 2)
assert meta_data['prev'].split('?', 1)[1] in ['per_page=8&page=1', 'page=1&per_page=8']
assert meta_data['next'].split('?', 1)[1] in ['per_page=8&page=3', 'page=3&per_page=8']
assert meta_data['last'].split('?', 1)[1] in ['per_page=8&page=4', 'page=4&per_page=8']
assert meta_data['first'].split('?', 1)[1] in ['per_page=8&page=1', 'page=1&per_page=8']
assert meta_data['total'] == 30
assert meta_data['per_page'] == 8
assert meta_data['pages'] == 4
assert meta_data['page'] == 2
def test_pagination_metadata_with_args(self):
rv = self.client.get('/module-build-service/1/module-builds/?per_page=8&page=2&order_by=id')
meta_data = json.loads(rv.data)['meta']
for link in [meta_data['prev'], meta_data['next'], meta_data['last'], meta_data['first']]:
self.assertIn('order_by=id', link)
self.assertIn('per_page=8', link)
self.assertEquals(meta_data['total'], 30)
self.assertEquals(meta_data['per_page'], 8)
self.assertEquals(meta_data['pages'], 4)
self.assertEquals(meta_data['page'], 2)
assert 'order_by=id' in link
assert 'per_page=8' in link
assert meta_data['total'] == 30
assert meta_data['per_page'] == 8
assert meta_data['pages'] == 4
assert meta_data['page'] == 2
def test_query_builds(self):
rv = self.client.get('/module-build-service/1/module-builds/?per_page=2')
@@ -315,7 +310,7 @@ class TestViews(unittest.TestCase):
'version': '2'
}
]
self.assertEquals(items, expected)
assert items == expected
def test_query_builds_with_id_error(self):
rv = self.client.get('/module-build-service/1/module-builds/?id=1')
@@ -327,142 +322,140 @@ class TestViews(unittest.TestCase):
'message': msg,
"status": 400
}
self.assertEqual(actual, expected)
assert actual == expected
def test_query_component_build(self):
rv = self.client.get('/module-build-service/1/component-builds/1')
data = json.loads(rv.data)
self.assertEquals(data['id'], 1)
self.assertEquals(data['format'], 'rpms')
self.assertEquals(data['module_build'], 1)
self.assertEquals(data['package'], 'nginx')
self.assertEquals(data['state'], 1)
self.assertEquals(data['state_name'], 'COMPLETE')
self.assertEquals(data['state_reason'], None)
self.assertEquals(data['task_id'], 12312345)
assert data['id'] == 1
assert data['format'] == 'rpms'
assert data['module_build'] == 1
assert data['package'] == 'nginx'
assert data['state'] == 1
assert data['state_name'] == 'COMPLETE'
assert data['state_reason'] is None
assert data['task_id'] == 12312345
def test_query_component_build_short(self):
rv = self.client.get('/module-build-service/1/component-builds/1?short=True')
data = json.loads(rv.data)
self.assertEquals(data['id'], 1)
self.assertEquals(data['format'], 'rpms')
self.assertEquals(data['module_build'], 1)
self.assertEquals(data['package'], 'nginx')
self.assertEquals(data['state'], 1)
self.assertEquals(data['state_name'], 'COMPLETE')
self.assertEquals(data['state_reason'], None)
self.assertEquals(data['task_id'], 12312345)
assert data['id'] == 1
assert data['format'] == 'rpms'
assert data['module_build'] == 1
assert data['package'] == 'nginx'
assert data['state'] == 1
assert data['state_name'] == 'COMPLETE'
assert data['state_reason'] is None
assert data['task_id'] == 12312345
def test_query_component_build_verbose(self):
rv = self.client.get('/module-build-service/1/component-builds/3?verbose=true')
data = json.loads(rv.data)
self.assertEquals(data['id'], 3)
self.assertEquals(data['format'], 'rpms')
self.assertEquals(data['module_build'], 2)
self.assertEquals(data['package'], 'postgresql')
self.assertEquals(data['state'], 1)
self.assertEquals(data['state_name'], 'COMPLETE')
self.assertEquals(data['state_reason'], None)
self.assertEquals(data['task_id'], 2433433)
self.assertEquals(data['state_trace'][0]['reason'], None)
self.assertTrue(data['state_trace'][0]['time'] is not None)
self.assertEquals(data['state_trace'][0]['state'], 1)
self.assertEquals(data['state_trace'][0]['state_name'], 'wait')
self.assertEquals(data['state_url'], '/module-build-service/1/component-builds/3')
component_builds_filters = ['tagged', 'ref', 'format']
assert data['id'] == 3
assert data['format'] == 'rpms'
assert data['module_build'] == 2
assert data['package'] == 'postgresql'
assert data['state'] == 1
assert data['state_name'] == 'COMPLETE'
assert data['state_reason'] is None
assert data['task_id'] == 2433433
assert data['state_trace'][0]['reason'] is None
assert data['state_trace'][0]['time'] is not None
assert data['state_trace'][0]['state'] == 1
assert data['state_trace'][0]['state_name'] == 'wait'
assert data['state_url'], '/module-build-service/1/component-builds/3'
def test_query_component_builds_filter_format(self):
rv = self.client.get('/module-build-service/1/component-builds/'
'?format=rpms')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 60)
assert data['meta']['total'] == 60
def test_query_component_builds_filter_ref(self):
rv = self.client.get('/module-build-service/1/component-builds/'
'?ref=this-filter-query-should-return-zero-items')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 0)
assert data['meta']['total'] == 0
def test_query_component_builds_filter_tagged(self):
rv = self.client.get('/module-build-service/1/component-builds/?tagged=true')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 40)
assert data['meta']['total'] == 40
def test_query_component_builds_filter_nvr(self):
rv = self.client.get('/module-build-service/1/component-builds/?nvr=nginx-1.10.1-2.'
'module%2B1%2Bb8661ee4')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 1)
assert data['meta']['total'] == 1
def test_query_component_builds_filter_task_id(self):
rv = self.client.get('/module-build-service/1/component-builds/?task_id=12312346')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 1)
assert data['meta']['total'] == 1
def test_query_builds_filter_name(self):
rv = self.client.get('/module-build-service/1/module-builds/?name=nginx')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 10)
assert data['meta']['total'] == 10
def test_query_builds_filter_koji_tag(self):
rv = self.client.get('/module-build-service/1/module-builds/?koji_tag=module-nginx-1.2')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 10)
assert data['meta']['total'] == 10
def test_query_builds_filter_completed_before(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?completed_before=2016-09-03T11:30:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 2)
assert data['meta']['total'] == 2
def test_query_builds_filter_completed_after(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?completed_after=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 8)
assert data['meta']['total'] == 8
def test_query_builds_filter_submitted_before(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?submitted_before=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 7)
assert data['meta']['total'] == 7
def test_query_builds_filter_submitted_after(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?submitted_after=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 23)
assert data['meta']['total'] == 23
def test_query_builds_filter_modified_before(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?modified_before=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 6)
assert data['meta']['total'] == 6
def test_query_builds_filter_modified_after(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?modified_after=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 24)
assert data['meta']['total'] == 24
def test_query_builds_filter_owner(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?owner=Moe%20Szyslak')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 10)
assert data['meta']['total'] == 10
def test_query_builds_filter_state(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?state=3')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 20)
assert data['meta']['total'] == 20
def test_query_builds_two_filters(self):
rv = self.client.get('/module-build-service/1/module-builds/?owner=Moe%20Szyslak'
'&modified_after=2016-09-03T12:25:00Z')
data = json.loads(rv.data)
self.assertEquals(data['meta']['total'], 4)
assert data['meta']['total'] == 4
def test_query_builds_filter_nsv(self):
rv = self.client.get(
@@ -470,19 +463,19 @@ class TestViews(unittest.TestCase):
data = json.loads(rv.data)
# TODO: The nsv should really be unique in the test data
for item in data['items']:
self.assertEqual(item['name'], 'postgressql')
self.assertEqual(item['stream'], '1')
self.assertEqual(item['version'], '2')
self.assertEquals(data['meta']['total'], 10)
assert item['name'] == 'postgressql'
assert item['stream'] == '1'
assert item['version'] == '2'
assert data['meta']['total'] == 10
def test_query_builds_filter_invalid_date(self):
rv = self.client.get(
'/module-build-service/1/module-builds/?modified_after=2016-09-03T12:25:00-05:00')
data = json.loads(rv.data)
self.assertEquals(data['error'], 'Bad Request')
self.assertEquals(data['message'], 'An invalid Zulu ISO 8601 timestamp'
' was provided for the \"modified_after\" parameter')
self.assertEquals(data['status'], 400)
assert data['error'] == 'Bad Request'
assert data['message'] == ('An invalid Zulu ISO 8601 timestamp was '
'provided for the \"modified_after\" parameter')
assert data['status'] == 400
def test_query_builds_order_by(self):
build = db.session.query(module_build_service.models.ModuleBuild).filter_by(id=2).one()
@@ -492,8 +485,8 @@ class TestViews(unittest.TestCase):
rv = self.client.get('/module-build-service/1/module-builds/?'
'per_page=10&order_by=name')
items = json.loads(rv.data)['items']
self.assertEqual(items[0]['name'], 'candy')
self.assertEqual(items[1]['name'], 'nginx')
assert items[0]['name'] == 'candy'
assert items[1]['name'] == 'nginx'
def test_query_builds_order_desc_by(self):
rv = self.client.get('/module-build-service/1/module-builds/?'
@@ -501,7 +494,7 @@ class TestViews(unittest.TestCase):
items = json.loads(rv.data)['items']
# Check that the id is items[0]["id"], items[0]["id"] - 1, ...
for idx, item in enumerate(items):
self.assertEquals(item["id"], items[0]["id"] - idx)
assert item["id"] == items[0]["id"] - idx
def test_query_builds_order_by_order_desc_by(self):
"""
@@ -513,17 +506,15 @@ class TestViews(unittest.TestCase):
items = json.loads(rv.data)['items']
# Check that the id is items[0]["id"], items[0]["id"] - 1, ...
for idx, item in enumerate(items):
self.assertEquals(item["id"], items[0]["id"] - idx)
assert item["id"] == items[0]["id"] - idx
def test_query_builds_order_by_wrong_key(self):
rv = self.client.get('/module-build-service/1/module-builds/?'
'per_page=10&order_by=unknown')
data = json.loads(rv.data)
self.assertEquals(data['status'], 400)
self.assertEquals(data['error'], 'Bad Request')
self.assertEquals(
data['message'], 'An invalid order_by or order_desc_by key '
'was supplied')
assert data['status'] == 400
assert data['error'] == 'Bad Request'
assert data['message'] == 'An invalid order_by or order_desc_by key was supplied'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -537,24 +528,23 @@ class TestViews(unittest.TestCase):
data = json.loads(rv.data)
assert 'component_builds' in data, data
self.assertEquals(data['component_builds'], [])
self.assertEquals(data['name'], 'testmodule')
self.assertEquals(data['scmurl'],
('git://pkgs.stg.fedoraproject.org/modules/testmodule'
'.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'))
self.assertEquals(data['version'], '1')
self.assertTrue(data['time_submitted'] is not None)
self.assertTrue(data['time_modified'] is not None)
self.assertEquals(data['time_completed'], None)
self.assertEquals(data['stream'], 'master')
self.assertEquals(data['owner'], 'Homer J. Simpson')
self.assertEquals(data['id'], 31)
self.assertEquals(data['rebuild_strategy'], 'changed-and-after')
self.assertEquals(data['state_name'], 'init')
self.assertEquals(data['state_url'], '/module-build-service/1/module-builds/31')
self.assertEquals(len(data['state_trace']), 1)
self.assertEquals(data['state_trace'][0]['state'], 0)
self.assertDictEqual(data['tasks'], {})
assert data['component_builds'] == []
assert data['name'] == 'testmodule'
assert data['scmurl'] == ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git'
'?#68931c90de214d9d13feefbd35246a81b6cb8d49')
assert data['version'] == '1'
assert data['time_submitted'] is not None
assert data['time_modified'] is not None
assert data['time_completed'] is None
assert data['stream'] == 'master'
assert data['owner'] == 'Homer J. Simpson'
assert data['id'] == 31
assert data['rebuild_strategy'] == 'changed-and-after'
assert data['state_name'] == 'init'
assert data['state_url'] == '/module-build-service/1/module-builds/31'
assert len(data['state_trace']) == 1
assert data['state_trace'][0]['state'] == 0
assert data['tasks'] == {}
mmd = _modulemd.ModuleMetadata()
mmd.loads(data["modulemd"])
@@ -571,7 +561,7 @@ class TestViews(unittest.TestCase):
'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
'#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
data = json.loads(rv.data)
self.assertEquals(data['rebuild_strategy'], 'only-changed')
assert data['rebuild_strategy'] == 'only-changed'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -589,13 +579,13 @@ class TestViews(unittest.TestCase):
'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
'#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 400)
assert rv.status_code == 400
expected_error = {
'error': 'Bad Request',
'message': ('The rebuild method of "only-changed" is not allowed. Choose from: all.'),
'status': 400
}
self.assertEqual(data, expected_error)
assert data == expected_error
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -608,14 +598,14 @@ class TestViews(unittest.TestCase):
'scmurl': ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git?'
'#68931c90de214d9d13feefbd35246a81b6cb8d49')}))
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 400)
assert rv.status_code == 400
expected_error = {
'error': 'Bad Request',
'message': ('The request contains the "rebuild_strategy" parameter but overriding '
'the default isn\'t allowed'),
'status': 400
}
self.assertEqual(data, expected_error)
assert data == expected_error
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -628,20 +618,19 @@ class TestViews(unittest.TestCase):
'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertEquals(data['component_builds'], [])
self.assertEquals(data['name'], 'fakemodule')
self.assertEquals(data['scmurl'],
('git://pkgs.stg.fedoraproject.org/modules/testmodule'
'.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'))
self.assertEquals(data['version'], '1')
self.assertTrue(data['time_submitted'] is not None)
self.assertTrue(data['time_modified'] is not None)
self.assertEquals(data['time_completed'], None)
self.assertEquals(data['stream'], 'master')
self.assertEquals(data['owner'], 'Homer J. Simpson')
self.assertEquals(data['id'], 31)
self.assertEquals(data['state_name'], 'init')
self.assertEquals(data['rebuild_strategy'], 'changed-and-after')
assert data['component_builds'] == []
assert data['name'] == 'fakemodule'
assert data['scmurl'] == ('git://pkgs.stg.fedoraproject.org/modules/testmodule.git'
'?#68931c90de214d9d13feefbd35246a81b6cb8d49')
assert data['version'] == '1'
assert data['time_submitted'] is not None
assert data['time_modified'] is not None
assert data['time_completed'] is None
assert data['stream'] == 'master'
assert data['owner'] == 'Homer J. Simpson'
assert data['id'] == 31
assert data['state_name'] == 'init'
assert data['rebuild_strategy'] == 'changed-and-after'
def test_submit_build_auth_error(self):
base_dir = path.abspath(path.dirname(__file__))
@@ -651,22 +640,18 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#48931b90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertEquals(
data['message'],
"No 'authorization' header found."
)
self.assertEquals(data['status'], 401)
self.assertEquals(data['error'], 'Unauthorized')
assert data['message'] == "No 'authorization' header found."
assert data['status'] == 401
assert data['error'] == 'Unauthorized'
@patch('module_build_service.auth.get_user', return_value=user)
def test_submit_build_scm_url_error(self, mocked_get_user):
rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
{'branch': 'master', 'scmurl': 'git://badurl.com'}))
data = json.loads(rv.data)
self.assertEquals(data['message'], 'The submitted scmurl '
'git://badurl.com is not allowed')
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['message'] == 'The submitted scmurl git://badurl.com is not allowed'
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=user)
def test_submit_build_scm_url_without_hash(self, mocked_get_user):
@@ -674,11 +659,10 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git'}))
data = json.loads(rv.data)
self.assertEquals(data['message'], 'The submitted scmurl '
'git://pkgs.stg.fedoraproject.org/modules/testmodule.git '
'is not valid')
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['message'] == ('The submitted scmurl git://pkgs.stg.fedoraproject.org'
'/modules/testmodule.git is not valid')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -689,9 +673,9 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertTrue(data['message'].startswith('Invalid modulemd:'))
self.assertEquals(data['status'], 422)
self.assertEquals(data['error'], 'Unprocessable Entity')
assert data['message'].startswith('Invalid modulemd:') is True
assert data['status'] == 422
assert data['error'] == 'Unprocessable Entity'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -704,8 +688,8 @@ class TestViews(unittest.TestCase):
'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=other_user)
def test_cancel_build(self, mocked_get_user):
@@ -713,8 +697,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['state'], 4)
self.assertEquals(data['state_reason'], 'Canceled by some_other_user.')
assert data['state'] == 4
assert data['state_reason'] == 'Canceled by some_other_user.'
@patch('module_build_service.auth.get_user', return_value=other_user)
def test_cancel_build_already_failed(self, mocked_get_user):
@@ -726,8 +710,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=('sammy', set()))
def test_cancel_build_unauthorized_no_groups(self, mocked_get_user):
@@ -735,8 +719,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=('sammy', set(["packager"])))
def test_cancel_build_unauthorized_not_owner(self, mocked_get_user):
@@ -744,8 +728,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user',
return_value=('sammy', set(["packager", "mbs-admin"])))
@@ -756,8 +740,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['state'], 4)
self.assertEquals(data['state_reason'], 'Canceled by sammy.')
assert data['state'] == 4
assert data['state_reason'] == 'Canceled by sammy.'
@patch('module_build_service.auth.get_user',
return_value=('sammy', set(["packager"])))
@@ -768,8 +752,8 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'failed'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=other_user)
def test_cancel_build_wrong_param(self, mocked_get_user):
@@ -777,10 +761,9 @@ class TestViews(unittest.TestCase):
data=json.dumps({'some_param': 'value'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 400)
self.assertEquals(data['error'], 'Bad Request')
self.assertEquals(
data['message'], 'Invalid JSON submitted')
assert data['status'] == 400
assert data['error'] == 'Bad Request'
assert data['message'] == 'Invalid JSON submitted'
@patch('module_build_service.auth.get_user', return_value=other_user)
def test_cancel_build_wrong_state(self, mocked_get_user):
@@ -788,10 +771,9 @@ class TestViews(unittest.TestCase):
data=json.dumps({'state': 'some_state'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 400)
self.assertEquals(data['error'], 'Bad Request')
self.assertEquals(
data['message'], 'The provided state change is not supported')
assert data['status'] == 400
assert data['error'] == 'Bad Request'
assert data['message'] == 'The provided state change is not supported'
@patch('module_build_service.auth.get_user', return_value=user)
def test_submit_build_unsupported_scm_scheme(self, mocked_get_user):
@@ -800,14 +782,10 @@ class TestViews(unittest.TestCase):
rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(
{'branch': 'master', 'scmurl': scmurl}))
data = json.loads(rv.data)
self.assertIn(
data['message'], (
"The submitted scmurl {} is not allowed".format(scmurl),
"The submitted scmurl {} is not valid".format(scmurl),
)
)
self.assertEquals(data['status'], 403)
self.assertEquals(data['error'], 'Forbidden')
assert data['message'] in ("The submitted scmurl {} is not allowed".format(scmurl),
"The submitted scmurl {} is not valid".format(scmurl))
assert data['status'] == 403
assert data['error'] == 'Forbidden'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -819,13 +797,11 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 400)
self.assertEquals(
data['message'],
'The version "123456789" is already defined in the modulemd but '
'it shouldn\'t be since the version is generated based on the '
'commit time')
self.assertEquals(data['error'], 'Bad Request')
assert data['status'] == 400
assert data['message'] == ('The version "123456789" is already defined in the modulemd '
'but it shouldn\'t be since the version is generated based on '
'the commit time')
assert data['error'] == 'Bad Request'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -837,12 +813,10 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#68931c90de214d9d13feefbd35246a81b6cb8d49'}))
data = json.loads(rv.data)
self.assertEquals(data['status'], 400)
self.assertEquals(
data['message'],
'The stream "wrong_stream" that is stored in the modulemd does not '
'match the branch "master"')
self.assertEquals(data['error'], 'Bad Request')
assert data['status'] == 400
assert data['message'] == ('The stream "wrong_stream" that is stored in the modulemd '
'does not match the branch "master"')
assert data['error'] == 'Bad Request'
@patch('module_build_service.auth.get_user', return_value=user)
def test_submit_build_set_owner(self, mocked_get_user):
@@ -854,8 +828,8 @@ class TestViews(unittest.TestCase):
}
rv = self.client.post('/module-build-service/1/module-builds/', data=json.dumps(data))
result = json.loads(rv.data)
self.assertEquals(result['status'], 400)
self.assertIn("The request contains 'owner' parameter", result['message'])
assert result['status'] == 400
assert "The request contains 'owner' parameter" in result['message']
@patch('module_build_service.auth.get_user', return_value=anonymous_user)
@patch('module_build_service.scm.SCM')
@@ -875,7 +849,7 @@ class TestViews(unittest.TestCase):
result = json.loads(rv.data)
build = ModuleBuild.query.filter(ModuleBuild.id == result['id']).one()
self.assertTrue(build.owner == result['owner'] == 'foo')
assert (build.owner == result['owner'] == 'foo') is True
@patch('module_build_service.auth.get_user', return_value=anonymous_user)
@patch('module_build_service.scm.SCM')
@@ -896,15 +870,15 @@ class TestViews(unittest.TestCase):
url = '/module-build-service/1/module-builds/' + str(r1['id'])
r2 = self.client.patch(url, data=json.dumps({'state': 'failed'}))
self.assertEquals(r2.status_code, 403)
assert r2.status_code == 403
r3 = self.client.patch(url, data=json.dumps({'state': 'failed', 'owner': 'foo'}))
self.assertEquals(r3.status_code, 200)
assert r3.status_code == 200
mocked_no_auth.return_value = False
r3 = self.client.patch(url, data=json.dumps({'state': 'failed', 'owner': 'foo'}))
self.assertEquals(r3.status_code, 400)
self.assertIn("The request contains 'owner' parameter", json.loads(r3.data)['message'])
assert r3.status_code == 400
assert "The request contains 'owner' parameter" in json.loads(r3.data)['message']
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -916,12 +890,10 @@ class TestViews(unittest.TestCase):
{'branch': 'master', 'scmurl': 'git://pkgs.stg.fedoraproject.org/modules/'
'testmodule.git?#7035bd33614972ac66559ac1fdd019ff6027ad22'}))
data = json.loads(rv.data)
self.assertIn("The requested commit hash was not found within the repository.",
data['message'])
self.assertIn("Perhaps you forgot to push. The original message was: ",
data['message'])
self.assertEquals(data['status'], 422)
self.assertEquals(data['error'], 'Unprocessable Entity')
assert "The requested commit hash was not found within the repository." in data['message']
assert "Perhaps you forgot to push. The original message was: " in data['message']
assert data['status'] == 422
assert data['error'] == 'Unprocessable Entity'
@patch('module_build_service.auth.get_user', return_value=user)
@patch('module_build_service.scm.SCM')
@@ -937,26 +909,26 @@ class TestViews(unittest.TestCase):
allow_custom_scmurls.return_value = False
res1 = submit('git://some.custom.url.org/modules/testmodule.git?#68931c9')
data = json.loads(res1.data)
self.assertEquals(data['status'], 403)
self.assertTrue(data['message'].startswith('The submitted scmurl'))
self.assertTrue(data['message'].endswith('is not allowed'))
assert data['status'] == 403
assert data['message'].startswith('The submitted scmurl') is True
assert data['message'].endswith('is not allowed') is True
allow_custom_scmurls.return_value = True
res2 = submit('git://some.custom.url.org/modules/testmodule.git?#68931c9')
self.assertEquals(res2.status_code, 201)
assert res2.status_code == 201
def test_about(self):
with patch.object(mbs_config.Config, 'auth_method', new_callable=PropertyMock) as auth:
auth.return_value = 'kerberos'
rv = self.client.get('/module-build-service/1/about/')
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 200)
self.assertEquals(data, {'auth_method': 'kerberos', 'version': version})
assert rv.status_code == 200
assert data == {'auth_method': 'kerberos', 'version': version}
def test_rebuild_strategy_api(self):
rv = self.client.get('/module-build-service/1/rebuild-strategies/')
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 200)
assert rv.status_code == 200
expected = {
'items': [
{
@@ -980,14 +952,14 @@ class TestViews(unittest.TestCase):
}
]
}
self.assertEquals(data, expected)
assert data == expected
def test_rebuild_strategy_api_only_changed_default(self):
with patch.object(mbs_config.Config, 'rebuild_strategy', new_callable=PropertyMock) as r_s:
r_s.return_value = 'only-changed'
rv = self.client.get('/module-build-service/1/rebuild-strategies/')
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 200)
assert rv.status_code == 200
expected = {
'items': [
{
@@ -1011,7 +983,7 @@ class TestViews(unittest.TestCase):
}
]
}
self.assertEquals(data, expected)
assert data == expected
def test_rebuild_strategy_api_override_allowed(self):
with patch.object(mbs_config.Config, 'rebuild_strategy_allow_override',
@@ -1019,7 +991,7 @@ class TestViews(unittest.TestCase):
rsao.return_value = True
rv = self.client.get('/module-build-service/1/rebuild-strategies/')
data = json.loads(rv.data)
self.assertEqual(rv.status_code, 200)
assert rv.status_code == 200
expected = {
'items': [
{
@@ -1043,8 +1015,8 @@ class TestViews(unittest.TestCase):
}
]
}
self.assertEquals(data, expected)
assert data == expected
def test_cors_header_decorator(self):
rv = self.client.get('/module-build-service/1/module-builds/')
self.assertEquals(rv.headers['Access-Control-Allow-Origin'], '*')
assert rv.headers['Access-Control-Allow-Origin'] == '*'