From be346a65d358addaa055570b037ff88a2502ba7a Mon Sep 17 00:00:00 2001 From: Ekaterina Chernova Date: Tue, 24 Apr 2018 13:50:03 +0300 Subject: [PATCH] [tests] Add teardown methods for fixtures * So all resources such as database objects wil be cleaned after each test * Delete objects, created in tests * Fix modifying env variables (monkeypatching that is used previously changes it for the whole session, so it affects other tests) --- kqueen/auth/test_ldap.py | 3 + kqueen/blueprints/api/test_cluster.py | 75 +++--- kqueen/blueprints/api/test_crud.py | 89 ++++--- kqueen/blueprints/api/test_helpers.py | 19 +- kqueen/blueprints/api/test_organization.py | 4 +- kqueen/blueprints/api/test_provisioner.py | 4 +- kqueen/blueprints/api/test_user.py | 8 +- kqueen/blueprints/api/tests.py | 8 +- kqueen/conftest.py | 259 ++++++++++++++------- kqueen/engines/test_manual.py | 18 +- kqueen/storages/test_client.py | 16 +- kqueen/tests/test_manual_cluster.py | 8 +- kqueen/tests/test_models.py | 7 + 13 files changed, 319 insertions(+), 199 deletions(-) diff --git a/kqueen/auth/test_ldap.py b/kqueen/auth/test_ldap.py index b1d26322..fa2ae341 100644 --- a/kqueen/auth/test_ldap.py +++ b/kqueen/auth/test_ldap.py @@ -16,6 +16,9 @@ def setup(self, user): self.auth_class = LDAPAuth(uri='ldap://127.0.0.1', admin_dn='cn=admin,dc=example,dc=org', _password='heslo123') + def teardown(self): + self.user.delete() + def test_raise_on_missing_creds(self): with pytest.raises(Exception, msg='Failed to configure LDAP, please provide valid LDAP credentials'): LDAPAuth() diff --git a/kqueen/blueprints/api/test_cluster.py b/kqueen/blueprints/api/test_cluster.py index 8f894027..8e93c1e2 100644 --- a/kqueen/blueprints/api/test_cluster.py +++ b/kqueen/blueprints/api/test_cluster.py @@ -1,19 +1,29 @@ from .test_crud import BaseTestCRUD from flask import url_for from kqueen.config import current_config -from kqueen.conftest import cluster -from uuid import uuid4 +from kqueen.conftest import ClusterFixture, ProvisionerFixture import json import pytest +from uuid import uuid4 config = current_config() class TestClusterCRUD(BaseTestCRUD): - def get_object(self): - obj = cluster() + @pytest.fixture(autouse=True) + def setup(self, client): + super().setup(client) + self.user = self.test_user.obj + self.test_provisioner = ProvisionerFixture(self.test_user) + self.provisioner = self.test_provisioner.obj + + def teardown(self): + super().teardown() + self.test_provisioner.destroy() + def get_object(self): + obj = ClusterFixture() return obj def get_edit_data(self): @@ -74,7 +84,7 @@ def test_crud_list(self): ) assert obj.get_dict(expand=True) in data - @pytest.mark.parametrize('cluster_id,status_code', [ + @pytest.mark.parametrize('cluster_id, status_code', [ (uuid4(), 404), ('wrong-uuid', 404), ]) @@ -148,14 +158,13 @@ def test_progress_format(self): assert 'progress' in response.json assert 'result' in response.json - def test_create(self, provisioner, user): - provisioner.save() - user.save() + def test_create(self): + self.provisioner.save() post_data = { 'name': 'Testing cluster', - 'provisioner': 'Provisioner:{}'.format(provisioner.id), - 'owner': 'User:{}'.format(user.id) + 'provisioner': 'Provisioner:{}'.format(self.provisioner.id), + 'owner': 'User:{}'.format(self.user.id) } response = self.client.post( @@ -169,11 +178,11 @@ def test_create(self, provisioner, user): assert 'id' in response.json assert response.json['name'] == post_data['name'] - assert response.json['provisioner'] == provisioner.get_dict(expand=True) + assert response.json['provisioner'] == self.provisioner.get_dict(expand=True) - def test_provision_after_create(self, provisioner, user, monkeypatch): - provisioner.save() - user.save() + def test_provision_after_create(self, monkeypatch): + self.provisioner.save() + self.user.save() def fake_provision(self, *args, **kwargs): self.cluster.name = 'Provisioned' @@ -181,12 +190,12 @@ def fake_provision(self, *args, **kwargs): return True, None - monkeypatch.setattr(provisioner.get_engine_cls(), 'provision', fake_provision) + monkeypatch.setattr(self.provisioner.get_engine_cls(), 'provision', fake_provision) post_data = { 'name': 'Testing cluster', - 'provisioner': 'Provisioner:{}'.format(provisioner.id), - 'owner': 'User:{}'.format(user.id) + 'provisioner': 'Provisioner:{}'.format(self.provisioner.id), + 'owner': 'User:{}'.format(self.user.id) } response = self.client.post( @@ -202,19 +211,19 @@ def fake_provision(self, *args, **kwargs): assert response.status_code == 200 assert obj.name == 'Provisioned' - def test_provision_failed(self, provisioner, user, monkeypatch): - provisioner.save() - user.save() + def test_provision_failed(self, monkeypatch): + self.provisioner.save() + self.user.save() def fake_provision(self, *args, **kwargs): return False, 'Testing msg' - monkeypatch.setattr(provisioner.get_engine_cls(), 'provision', fake_provision) + monkeypatch.setattr(self.provisioner.get_engine_cls(), 'provision', fake_provision) post_data = { 'name': 'Testing cluster', - 'provisioner': 'Provisioner:{}'.format(provisioner.id), - 'owner': 'User:{}'.format(user.id) + 'provisioner': 'Provisioner:{}'.format(self.provisioner.id), + 'owner': 'User:{}'.format(self.user.id) } response = self.client.post( @@ -230,15 +239,15 @@ def fake_provision(self, *args, **kwargs): config.get('PROVISIONER_UNKNOWN_STATE'), config.get('PROVISIONER_ERROR_STATE') ]) - def test_provision_failed_with_unhealthy_provisioner(self, provisioner, user, provisioner_state): - provisioner.state = provisioner_state - provisioner.save(check_status=False) - user.save() + def test_provision_failed_with_unhealthy_provisioner(self, provisioner_state): + self.provisioner.state = provisioner_state + self.provisioner.save(check_status=False) + self.user.save() post_data = { 'name': 'Testing cluster', - 'provisioner': 'Provisioner:{}'.format(provisioner.id), - 'owner': 'User:{}'.format(user.id) + 'provisioner': 'Provisioner:{}'.format(self.provisioner.id), + 'owner': 'User:{}'.format(self.user.id) } response = self.client.post( @@ -274,8 +283,11 @@ def test_error_codes(self, data, code, content_type): assert response.status_code == code def test_cluster_list_run_get_state(self, monkeypatch): + clusters_to_remove = [] for _ in range(10): - c = cluster() + test_cluster = ClusterFixture() + clusters_to_remove.append(test_cluster) + c = test_cluster.obj c.save() def fake_get_state(self): @@ -298,3 +310,6 @@ def fake_get_state(self): assert obj.metadata, 'get_state wasn\'t executed for cluster {}'.format(obj) assert obj.metadata['executed'], 'get_state wasn\'t executed' + + for c in clusters_to_remove: + c.destroy() diff --git a/kqueen/blueprints/api/test_crud.py b/kqueen/blueprints/api/test_crud.py index b95366c5..00596810 100644 --- a/kqueen/blueprints/api/test_crud.py +++ b/kqueen/blueprints/api/test_crud.py @@ -1,7 +1,11 @@ from flask import url_for -from kqueen.conftest import auth_header, user_with_namespace, get_auth_token +from kqueen.conftest import AuthHeader +from kqueen.conftest import UserWithNamespaceFixture +from kqueen.conftest import UserFixture +from kqueen.conftest import etcd_setup from kqueen.config import current_config +import faker import json import pytest @@ -51,14 +55,23 @@ def get_urls(self, pk=None): ), } - def setup(self): - self.obj = self.get_object() + @pytest.fixture(autouse=True) + def setup(self, client): + etcd_setup() + self.test_object = self.get_object() + self.obj = self.test_object.obj self.obj.save() - - self.auth_header = auth_header(self.client) + self.test_user = UserFixture() + self.test_auth_header = AuthHeader(self.test_user) + self.auth_header = self.test_auth_header.get(client) self.namespace = self.auth_header['X-Test-Namespace'] + self.urls = self.get_urls() + def teardown(self): + self.test_auth_header.destroy() + self.test_object.destroy() + def test_crud_create(self): data = self.get_create_data() @@ -117,7 +130,7 @@ def test_crud_get(self): def test_crud_list(self): response = self.client.get( self.urls['list'], - headers=self.auth_header, + headers=self.auth_header ) data = response.json @@ -186,7 +199,7 @@ def fake_save(self, *args, **kwargs): def test_crud_delete(self): response = self.client.delete( self.urls['delete'], - headers=self.auth_header, + headers=self.auth_header ) assert response.status_code == 200 @@ -197,48 +210,38 @@ def test_crud_delete(self): ) def test_crud_delete_failed(self, monkeypatch): + original_delete = getattr(self.obj.__class__, 'delete') + def fake_delete(self, *args, **kwargs): raise Exception('Testing') monkeypatch.setattr(self.obj.__class__, 'delete', fake_delete) - response = self.client.delete( - self.urls['delete'], - headers=self.auth_header, - ) + response = self.client.delete(self.urls['delete'], headers=self.auth_header) assert response.status_code == 500 + monkeypatch.setattr(self.obj.__class__, 'delete', original_delete) # # namespacing tests # - @pytest.fixture - def setup_namespace(self): - self.user1 = user_with_namespace() - self.user2 = user_with_namespace() - @pytest.mark.usefixtures('setup_namespace') - def test_namespacing(self, client): - obj = self.get_object() + def test_namespacing(self): + user1 = UserWithNamespaceFixture() + user1.auth_header = AuthHeader(user1).get(self.client) + user2 = UserWithNamespaceFixture() + user2.auth_header = AuthHeader(user2).get(self.client) # skip if object class isn't namespaced - if not obj.__class__.is_namespaced(): - pytest.skip('Class {} isn\'t namespaced'.format(obj.__class__.__name__)) + if not self.obj.__class__.is_namespaced(): + pytest.skip('Class {} isn\'t namespaced'.format(self.obj.__class__.__name__)) objs = {} # create objects for both users - for u in [self.user1, self.user2]: + for u in [user1, user2]: data = self.get_create_data() - auth_header = get_auth_token(self.client, u) - headers = { - 'Authorization': '{} {}'.format( - config.get('JWT_AUTH_HEADER_PREFIX'), - auth_header - ) - } - # TODO: fix this # Dirty hack to make testing data namespaced. organization_data = { @@ -248,13 +251,14 @@ def test_namespacing(self, client): response = self.client.post( url_for('api.organization_create'), data=json.dumps(organization_data), - headers=headers, + headers=u.auth_header, content_type='application/json', ) organization_ref = 'Organization:{}'.format(response.json['id']) + profile = faker.Faker().simple_profile() owner_data = { - 'username': 'Test owner', - 'email': 'owner@pytest.org', + 'username': profile['username'], + 'email': profile['mail'], 'password': 'pytest', 'organization': organization_ref, 'role': 'admin', @@ -263,7 +267,7 @@ def test_namespacing(self, client): response = self.client.post( url_for('api.user_create'), data=json.dumps(owner_data), - headers=headers, + headers=u.auth_header, content_type='application/json', ) if 'owner' in data: @@ -277,7 +281,7 @@ def test_namespacing(self, client): response = self.client.post( url_for('api.provisioner_create'), data=json.dumps(provisioner_data), - headers=headers, + headers=u.auth_header, content_type='application/json', ) data['provisioner'] = 'Provisioner:{}'.format(response.json['id']) @@ -285,36 +289,29 @@ def test_namespacing(self, client): response = self.client.post( self.urls['create'], data=json.dumps(data), - headers=headers, + headers=u.auth_header, content_type='application/json', ) print(response.data.decode(response.charset)) - objs[u.namespace] = response.json['id'] + objs[u.obj.namespace] = response.json['id'] print(response.json) # test use can't read other's object - for u in [self.user1, self.user2]: - auth_header = get_auth_token(self.client, u) - headers = { - 'Authorization': '{} {}'.format( - config.get('JWT_AUTH_HEADER_PREFIX'), - auth_header - ) - } + for u in [user1, user2]: for ns, pk in objs.items(): url = self.get_urls(pk)['get'] - if ns == u.namespace: + if ns == u.obj.namespace: req_code = 200 else: req_code = 404 response = self.client.get( url, - headers=headers, + headers=u.auth_header, content_type='application/json', ) diff --git a/kqueen/blueprints/api/test_helpers.py b/kqueen/blueprints/api/test_helpers.py index d6f54d68..e2469dd4 100644 --- a/kqueen/blueprints/api/test_helpers.py +++ b/kqueen/blueprints/api/test_helpers.py @@ -1,21 +1,18 @@ from .helpers import get_object -from kqueen.conftest import cluster -from kqueen.conftest import user + from kqueen.storages.exceptions import BackendError import pytest +@pytest.mark.usefixtures('cluster', 'user') class TestGetObject: - def setup(self): - self.obj = cluster() - self.obj.save() - self.user = user() - def test_get_objects(self): - obj = get_object(self.obj.__class__, self.obj.id, self.user) + def test_get_objects(self, cluster, user): + cluster.save() + obj = get_object(cluster.__class__, cluster.id, user) - assert obj.get_dict(True) == self.obj.get_dict(True) + assert obj.get_dict(True) == obj.get_dict(True) @pytest.mark.parametrize('bad_user', [ 'None', @@ -23,6 +20,6 @@ def test_get_objects(self): None, {}, ]) - def test_get_object_malformed_user(self, bad_user): + def test_get_object_malformed_user(self, cluster, bad_user): with pytest.raises(BackendError, match='Missing namespace for class'): - get_object(self.obj.__class__, self.obj.id, bad_user) + get_object(cluster.__class__, cluster.id, bad_user) diff --git a/kqueen/blueprints/api/test_organization.py b/kqueen/blueprints/api/test_organization.py index 5ac6969c..1e82761d 100644 --- a/kqueen/blueprints/api/test_organization.py +++ b/kqueen/blueprints/api/test_organization.py @@ -1,7 +1,7 @@ from .test_crud import BaseTestCRUD from flask import url_for from kqueen.config import current_config -from kqueen.conftest import organization +from kqueen.conftest import OrganizationFixture import pytest @@ -10,7 +10,7 @@ class TestOrganizationCRUD(BaseTestCRUD): def get_object(self): - return organization() + return OrganizationFixture() def get_edit_data(self): return { diff --git a/kqueen/blueprints/api/test_provisioner.py b/kqueen/blueprints/api/test_provisioner.py index d7f4e9d2..58aa4c21 100644 --- a/kqueen/blueprints/api/test_provisioner.py +++ b/kqueen/blueprints/api/test_provisioner.py @@ -1,13 +1,13 @@ from .test_crud import BaseTestCRUD from flask import url_for -from kqueen.conftest import provisioner +from kqueen.conftest import ProvisionerFixture from kqueen.engines.__init__ import __all__ as all_engines from pprint import pprint as print class TestProvisionerCRUD(BaseTestCRUD): def get_object(self): - return provisioner() + return ProvisionerFixture() def get_edit_data(self): return { diff --git a/kqueen/blueprints/api/test_user.py b/kqueen/blueprints/api/test_user.py index a24c5cea..382cb5c9 100644 --- a/kqueen/blueprints/api/test_user.py +++ b/kqueen/blueprints/api/test_user.py @@ -1,18 +1,19 @@ from .test_crud import BaseTestCRUD from flask import url_for -from kqueen.conftest import user +from kqueen.conftest import UserFixture from kqueen.config import current_config import bcrypt import json import pytest + config = current_config() class TestUserCRUD(BaseTestCRUD): def get_object(self): - return user() + return UserFixture() def get_edit_data(self): return { @@ -24,6 +25,7 @@ def get_create_data(self): data = self.obj.get_dict() data['id'] = None data['organization'] = 'Organization:{}'.format(self.obj.organization.id) + data['username'] = 'newusername' return data @@ -58,7 +60,7 @@ def test_whoami(self): assert response.json == self.obj.get_dict(expand=True) def test_namespace(self): - user = self.get_object() + user = self.obj assert user.namespace == user.organization.namespace diff --git a/kqueen/blueprints/api/tests.py b/kqueen/blueprints/api/tests.py index 919ebf59..1a1da0f3 100644 --- a/kqueen/blueprints/api/tests.py +++ b/kqueen/blueprints/api/tests.py @@ -1,5 +1,5 @@ from flask import url_for -from kqueen.conftest import app +from kqueen.conftest import app, AuthHeader from uuid import uuid4 import pytest @@ -46,10 +46,12 @@ def get_urls(): return urls -def test_root(client, auth_header): - response = client.get(url_for('api.index'), headers=auth_header) +def test_root(client): + test_auth_header = AuthHeader() + response = client.get(url_for('api.index'), headers=test_auth_header.get(client)) assert response.json == {'response': 'Gutten tag!'} + test_auth_header.destroy() # TODO: fix bad request code diff --git a/kqueen/conftest.py b/kqueen/conftest.py index 847487c3..ff6ea111 100644 --- a/kqueen/conftest.py +++ b/kqueen/conftest.py @@ -20,6 +20,158 @@ current_app = None +class ClusterFixture: + def __init__(self, test_provisioner=None, test_user=None): + test_user = test_user if test_user is not None else UserFixture() + + if not test_provisioner: + test_provisioner = ProvisionerFixture(test_user=test_user) + self.test_provisioner = test_provisioner + + owner = test_user.obj + provisioner = self.test_provisioner.obj + + provisioner.state = config.get('PROVISIONER_OK_STATE') + provisioner.save(check_status=False) + + _uuid = uuid.uuid4() + create_kwargs = { + 'id': _uuid, + 'name': 'Name for cluster {}'.format(_uuid), + 'provisioner': provisioner, + 'state': config.get('CLUSTER_UNKNOWN_STATE'), + 'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()), + 'created_at': datetime.datetime.utcnow().replace(microsecond=0), + 'owner': owner + } + self.obj = Cluster.create(owner.namespace, **create_kwargs) + + def destroy(self): + try: + self.obj.delete() + self.test_provisioner.destroy() + except Exception: + # Provisioner may be already deleted + pass + + +class ProvisionerFixture: + def __init__(self, test_user=None): + if test_user is None: + test_user = UserFixture() + self.test_user = test_user + + owner = test_user.obj + create_kwargs = { + 'name': 'Fixtured provisioner', + 'engine': 'kqueen.engines.ManualEngine', + 'owner': owner + } + self.obj = Provisioner.create(owner.namespace, **create_kwargs) + + def destroy(self): + try: + self.obj.delete() + self.test_user.destroy() + except Exception: + # Provisioner may be already deleted + pass + + +class UserFixture: + def __init__(self): + profile = fake.simple_profile() + self.test_org = OrganizationFixture() + user = User.create( + None, + username=profile['username'], + password=profile['username'] + 'password', + organization=self.test_org.obj, + role='superadmin', + active=True + ) + user.save() + self.obj = user + + def destroy(self): + try: + self.obj.delete() + self.test_org.destroy() + except Exception: + # User be may already deleted + pass + + +class OrganizationFixture: + def __init__(self): + """Prepare organization object.""" + organization = Organization( + None, + name='DemoOrg', + namespace='demoorg', + ) + organization.save() + self.obj = organization + + def destroy(self): + try: + self.obj.delete() + except Exception: + # Organization be may already deleted + pass + + +class AuthHeader: + def __init__(self, test_user=None): + self.user = test_user if test_user is not None else UserFixture() + + def get(self, client): + """ + Get JWT access token and convert it to HTTP header. + + Args: + client: Flask client + + Returns: + dict: {'Authorization': 'JWT access_token'} + + """ + _user = self.user.obj + token = get_auth_token(client, _user) + + return { + 'Authorization': '{token_prefix} {token}'.format( + token_prefix=config.get('JWT_AUTH_HEADER_PREFIX'), + token=token, + ), + 'X-Test-Namespace': _user.namespace, + 'X-User': str(_user.id), + } + + def destroy(self): + self.user.destroy() + + +class UserWithNamespaceFixture: + def __init__(self): + self.test_org = OrganizationFixture() + org = self.test_org.obj + + namespace = fake.user_name() + org.namespace = namespace + org.save() + + self.test_user = UserFixture() + _user = self.test_user.obj + _user.organization = org + _user.save() + self.obj = _user + + def destroy(self): + self.test_org.destroy() + self.test_user.destroy() + + @pytest.fixture(autouse=True, scope='session') def app(): """Prepare app.""" @@ -42,43 +194,18 @@ def etcd_setup(): @pytest.fixture def cluster(): """Create cluster with manual provisioner.""" - _uuid = uuid.uuid4() - _user = user() - - prov = Provisioner( - _user.namespace, - name='Fixtured provisioner', - engine='kqueen.engines.ManualEngine', - owner=_user - ) - prov.state = config.get('PROVISIONER_OK_STATE') - prov.save(check_status=False) - - create_kwargs = { - 'id': _uuid, - 'name': 'Name for cluster {}'.format(_uuid), - 'provisioner': prov, - 'state': config.get('CLUSTER_UNKNOWN_STATE'), - 'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()), - 'created_at': datetime.datetime.utcnow().replace(microsecond=0), - 'owner': _user - } - - return Cluster.create(_user.namespace, **create_kwargs) + test_cluster = ClusterFixture() + yield test_cluster.obj + test_cluster.destroy() @pytest.fixture def provisioner(): """Create dummy manual provisioner.""" - _user = user() - - create_kwargs = { - 'name': 'Fixtured provisioner', - 'engine': 'kqueen.engines.ManualEngine', - 'owner': _user - } - - return Provisioner.create(_user.namespace, **create_kwargs) + test_provisioner = ProvisionerFixture() + test_provisioner.obj.save() + yield test_provisioner.obj + test_provisioner.destroy() def get_auth_token(_client, _user): @@ -111,72 +238,26 @@ def get_auth_token(_client, _user): return token -@pytest.fixture -def auth_header(client): - """ - Get JWT access token and convert it to HTTP header. - - Args: - client: Flask client - - Returns: - dict: {'Authorization': 'JWT access_token'} - - """ - _user = user() - token = get_auth_token(client, _user) - - return { - 'Authorization': '{token_prefix} {token}'.format( - token_prefix=config.get('JWT_AUTH_HEADER_PREFIX'), - token=token, - ), - 'X-Test-Namespace': _user.namespace, - 'X-User': str(_user.id), - } - - -@pytest.fixture -def organization(): - """Prepare organization object.""" - with current_app.app_context(): - organization = Organization( - None, - name='DemoOrg', - namespace='demoorg', - ) - organization.save() - - return organization - - -@pytest.fixture(scope='class') +@pytest.fixture(scope='class', autouse=True) def user(): """Prepare user object.""" with current_app.app_context(): + test_org = OrganizationFixture() profile = fake.simple_profile() user = User.create( None, username=profile['username'], password=profile['username'] + 'password', - organization=organization(), + organization=test_org.obj, role='superadmin', active=True ) - user.save() - - return user - - -@pytest.fixture -def user_with_namespace(): - - org = organization() - org.namespace = fake.user_name() - org.save() - _user = user() - _user.organization = org - _user.save() - - return _user + user.save() + yield user + try: + user.delete() + test_org.destroy() + except Exception: + # objects may be already deleted + pass diff --git a/kqueen/engines/test_manual.py b/kqueen/engines/test_manual.py index 42cbe610..46c729ed 100644 --- a/kqueen/engines/test_manual.py +++ b/kqueen/engines/test_manual.py @@ -1,10 +1,8 @@ from .manual import ManualEngine from flask import url_for from kqueen.config import current_config -from kqueen.conftest import auth_header -from kqueen.conftest import user -from kqueen.models import Cluster -from kqueen.models import Provisioner +from kqueen.conftest import AuthHeader, UserFixture +from kqueen.models import Cluster, Provisioner import json import pytest @@ -26,7 +24,8 @@ @pytest.mark.usefixtures('client_class') class ManualEngineBase: def setup(self): - _user = user() + self.test_user = UserFixture() + _user = self.test_user.obj create_kwargs_provisioner = { 'name': 'Testing manual', 'engine': 'kqueen.engines.ManualEngine', @@ -48,12 +47,19 @@ def setup(self): } self.cluster = Cluster.create(_user.namespace, **self.create_kwargs_cluster) + self.cluster.save() + self.engine = ManualEngine(cluster=self.cluster) # client setup - self.auth_header = auth_header(self.client) + self.auth_header = AuthHeader(self.test_user).get(self.client) self.namespace = self.auth_header['X-Test-Namespace'] + def teardown(self): + + self.engine.deprovision() + self.test_user.destroy() + class TestClusterAction(ManualEngineBase): def test_initialization(self): diff --git a/kqueen/storages/test_client.py b/kqueen/storages/test_client.py index 9f6bd378..e53f2c43 100644 --- a/kqueen/storages/test_client.py +++ b/kqueen/storages/test_client.py @@ -1,19 +1,25 @@ from .etcd import EtcdBackend -import pytest + +import os class TestEtcdClient: - @pytest.fixture(autouse=True) - def prepare(self, monkeypatch): + def setup(self): self.set_vars = { 'KQUEEN_ETCD_HOST': 'etcd-server', 'KQUEEN_ETCD_PORT': '1234', } - + self.existent = {} for name, value in self.set_vars.items(): - monkeypatch.setenv(name, value) + if name in os.environ: + self.existent[name] = os.environ[name] + os.environ[name] = value def test_config_fields(self): orm = EtcdBackend() assert orm.client.host == self.set_vars['KQUEEN_ETCD_HOST'] assert orm.client.port == int(self.set_vars['KQUEEN_ETCD_PORT']) + + def teardown(self): + for name, value in self.existent.items(): + os.environ[name] = value diff --git a/kqueen/tests/test_manual_cluster.py b/kqueen/tests/test_manual_cluster.py index 9d590837..0d47babf 100644 --- a/kqueen/tests/test_manual_cluster.py +++ b/kqueen/tests/test_manual_cluster.py @@ -1,5 +1,5 @@ from flask import url_for -from kqueen.conftest import auth_header +from kqueen.conftest import AuthHeader from kqueen.models import User from datetime import datetime @@ -11,12 +11,16 @@ @pytest.mark.usefixtures('client_class') class TestInsertManualCluster: def setup(self): - self.auth_header = auth_header(self.client) + self.auth_header_test = AuthHeader() + self.auth_header = self.auth_header_test.get(self.client) self.namespace = self.auth_header['X-Test-Namespace'] self.user = User.load(None, self.auth_header['X-User']) self.provisioner_id = None + def teardown(self): + self.auth_header_test.destroy() + def test_run(self): self.create_provisioner() self.get_provisioners() diff --git a/kqueen/tests/test_models.py b/kqueen/tests/test_models.py index cd79c5ed..5f6c483a 100644 --- a/kqueen/tests/test_models.py +++ b/kqueen/tests/test_models.py @@ -49,14 +49,18 @@ def test_id_generation(self, provisioner, user): empty = Cluster(provisioner._object_namespace, name='test', provisioner=provisioner, owner=user) empty.save() + empty.delete() + def test_added_key(self, cluster): """Test _key is added after saving""" + cluster_id = cluster.id cluster.id = None assert not hasattr(cluster, '_key') cluster.save() assert hasattr(cluster, '_key'), 'Saved object is missing _key' + cluster.id = cluster_id def test_exists(self, cluster): assert not Cluster.exists(cluster._object_namespace, cluster.id) @@ -65,10 +69,12 @@ def test_exists(self, cluster): assert Cluster.exists(cluster._object_namespace, cluster.id) def test_get_db_key_missing(self, cluster): + cluster_id = cluster.id cluster.id = None with pytest.raises(Exception, match=r'Missing object id'): cluster.get_db_key() + cluster.id = cluster_id def test_list_with_objects(self, cluster): cluster.save() @@ -205,6 +211,7 @@ def test_load_provisioner(self, user): loaded = Provisioner.load(user.namespace, provisioner.id) assert loaded.get_dict(True) == provisioner.get_dict(True) + provisioner.delete() class TestClusterState: