Change config validator tests to use the shared fixtures

util/config/validators/test/conftest.py

@@ -1,88 +0,0 @@
-import os
-
-import pytest
-import shutil
-from flask import Flask, jsonify
-from flask_login import LoginManager
-from peewee import SqliteDatabase
-
-from app import app as application
-from data import model
-from data.database import (close_db_filter, db)
-from data.model.user import LoginWrappedDBUser
-from endpoints.api import api_bp
-from initdb import initialize_database, populate_database
-from path_converters import APIRepositoryPathConverter, RegexConverter
-
-
-# TODO(jschorr): Unify with the API conftest once the other PR gets in.
-
-@pytest.fixture()
-def app(appconfig):
-  """ Used by pytest-flask plugin to inject app by test for client See test_security by name injection of client. """
-  app = Flask(__name__)
-  login_manager = LoginManager(app)
-
-  @app.errorhandler(model.DataModelException)
-  def handle_dme(ex):
-    response = jsonify({'message': ex.message})
-    response.status_code = 400
-    return response
-
-  @login_manager.user_loader
-  def load_user(user_uuid):
-    return LoginWrappedDBUser(user_uuid)
-
-  app.url_map.converters['regex'] = RegexConverter
-  app.url_map.converters['apirepopath'] = APIRepositoryPathConverter
-  app.register_blueprint(api_bp, url_prefix='/api')
-  app.config.update(appconfig)
-  return app
-
-
-@pytest.fixture(scope="session")
-def init_db_path(tmpdir_factory):
-  """ Creates a new db and appropriate configuration. Used for parameter by name injection. """
-  sqlitedb_file = str(tmpdir_factory.mktemp("data").join("test.db"))
-  sqlitedb = 'sqlite:///{0}'.format(sqlitedb_file)
-  conf = {"TESTING": True,
-          "DEBUG": True,
-          "DB_URI": sqlitedb}
-  os.environ['TEST_DATABASE_URI'] = str(sqlitedb)
-  os.environ['DB_URI'] = str(sqlitedb)
-  db.initialize(SqliteDatabase(sqlitedb_file))
-  application.config.update(conf)
-  application.config.update({"DB_URI": sqlitedb})
-  initialize_database()
-  populate_database()
-  close_db_filter(None)
-  return str(sqlitedb_file)
-
-
-@pytest.fixture()
-def database_uri(monkeypatch, init_db_path, sqlitedb_file):
-  """ Creates the db uri. Used for parameter by name injection. """
-  shutil.copy2(init_db_path, sqlitedb_file)
-  db.initialize(SqliteDatabase(sqlitedb_file))
-  db_path = 'sqlite:///{0}'.format(sqlitedb_file)
-  monkeypatch.setenv("DB_URI", db_path)
-  return db_path
-
-
-@pytest.fixture()
-def sqlitedb_file(tmpdir):
-  """ Makes file for db. Used for parameter by name injection. """
-  test_db_file = tmpdir.mkdir("quaydb").join("test.db")
-  return str(test_db_file)
-
-
-@pytest.fixture()
-def appconfig(database_uri):
-  """ Makes conf with database_uri. Used for parameter by name injection """
-  conf = {
-    "TESTING": True,
-    "DEBUG": True,
-    "DB_URI": database_uri,
-    "SECRET_KEY": 'superdupersecret!!!1',
-  }
-  return conf

util/config/validators/test/test_validate_bitbucket_trigger.py

@@ -5,19 +5,21 @@ from httmock import urlmatch, HTTMock
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_bitbucket_trigger import BitbucketTriggerValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'BITBUCKET_TRIGGER_CONFIG': {}}),
   ({'BITBUCKET_TRIGGER_CONFIG': {'CONSUMER_KEY': 'foo'}}),
   ({'BITBUCKET_TRIGGER_CONFIG': {'CONSUMER_SECRET': 'foo'}}),
 ])
-def test_validate_invalid_bitbucket_trigger_config(unvalidated_config):
+def test_validate_invalid_bitbucket_trigger_config(unvalidated_config, app):
   validator = BitbucketTriggerValidator()
 
   with pytest.raises(ConfigValidationException):
     validator.validate(unvalidated_config, None, None)
 
-def test_validate_bitbucket_trigger():
+def test_validate_bitbucket_trigger(app):
   url_hit = [False]
 
   @urlmatch(netloc=r'bitbucket.org')

util/config/validators/test/test_validate_database.py

@@ -3,6 +3,8 @@ import pytest
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_database import DatabaseValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config,user,user_password,expected', [
   (None, None, None, TypeError),
   ({}, None, None, KeyError),
@@ -11,7 +13,7 @@ from util.config.validators.validate_database import DatabaseValidator
   ({'DB_NOTURI': 'sqlite:///:memory:'}, None, None, KeyError),
   ({'DB_URI': 'mysql:///someinvalid'}, None, None, ConfigValidationException),
 ])
-def test_validate_database(unvalidated_config, user, user_password, expected):
+def test_validate_database(unvalidated_config, user, user_password, expected, app):
   validator = DatabaseValidator()
 
   if expected is not None:

util/config/validators/test/test_validate_github.py

@@ -5,6 +5,8 @@ from httmock import urlmatch, HTTMock
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_github import GitHubLoginValidator, GitHubTriggerValidator
 
+from test.fixtures import *
+
 @pytest.fixture(params=[GitHubLoginValidator, GitHubTriggerValidator])
 def github_validator(request):
   return request.param
@@ -30,13 +32,13 @@ def github_validator(request):
     'ALLOWED_ORGANIZATIONS': [],
   }),
 ])
-def test_validate_invalid_github_config(github_config, github_validator):
+def test_validate_invalid_github_config(github_config, github_validator, app):
   with pytest.raises(ConfigValidationException):
     unvalidated_config = {}
     unvalidated_config[github_validator.config_key] = github_config
     github_validator.validate(unvalidated_config, None, None)
 
-def test_validate_github(github_validator):
+def test_validate_github(github_validator, app):
   url_hit = [False, False]
 
   @urlmatch(netloc=r'somehost')

util/config/validators/test/test_validate_gitlab_trigger.py

@@ -6,19 +6,21 @@ from httmock import urlmatch, HTTMock
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_gitlab_trigger import GitLabTriggerValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'GITLAB_TRIGGER_CONFIG': {'GITLAB_ENDPOINT': 'foo'}}),
   ({'GITLAB_TRIGGER_CONFIG': {'GITLAB_ENDPOINT': 'http://someendpoint', 'CLIENT_ID': 'foo'}}),
   ({'GITLAB_TRIGGER_CONFIG': {'GITLAB_ENDPOINT': 'http://someendpoint', 'CLIENT_SECRET': 'foo'}}),
 ])
-def test_validate_invalid_gitlab_trigger_config(unvalidated_config):
+def test_validate_invalid_gitlab_trigger_config(unvalidated_config, app):
   validator = GitLabTriggerValidator()
 
   with pytest.raises(ConfigValidationException):
     validator.validate(unvalidated_config, None, None)
 
-def test_validate_gitlab_enterprise_trigger():
+def test_validate_gitlab_enterprise_trigger(app):
   url_hit = [False]
 
   @urlmatch(netloc=r'somegitlab', path='/oauth/token')

util/config/validators/test/test_validate_google_login.py

@@ -5,19 +5,21 @@ from httmock import urlmatch, HTTMock
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_google_login import GoogleLoginValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'GOOGLE_LOGIN_CONFIG': {}}),
   ({'GOOGLE_LOGIN_CONFIG': {'CLIENT_ID': 'foo'}}),
   ({'GOOGLE_LOGIN_CONFIG': {'CLIENT_SECRET': 'foo'}}),
 ])
-def test_validate_invalid_google_login_config(unvalidated_config):
+def test_validate_invalid_google_login_config(unvalidated_config, app):
   validator = GoogleLoginValidator()
 
   with pytest.raises(ConfigValidationException):
     validator.validate(unvalidated_config, None, None)
 
-def test_validate_google_login():
+def test_validate_google_login(app):
   url_hit = [False]
   @urlmatch(netloc=r'www.googleapis.com', path='/oauth2/v3/token')
   def handler(_, __):

util/config/validators/test/test_validate_jwt.py

@@ -6,12 +6,14 @@ from util.morecollections import AttrDict
 
 from test.test_external_jwt_authn import fake_jwt
 
+from test.fixtures import *
+
 
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'AUTHENTICATION_TYPE': 'Database'}),
 ])
-def test_validate_noop(unvalidated_config):
+def test_validate_noop(unvalidated_config, app):
   JWTAuthValidator.validate(unvalidated_config, None, None)
 
 
@@ -20,7 +22,7 @@ def test_validate_noop(unvalidated_config):
   ({'AUTHENTICATION_TYPE': 'JWT', 'JWT_AUTH_ISSUER': 'foo'}),
   ({'AUTHENTICATION_TYPE': 'JWT', 'JWT_VERIFY_ENDPOINT': 'foo'}),
 ])
-def test_invalid_config(unvalidated_config):
+def test_invalid_config(unvalidated_config, app):
   with pytest.raises(ConfigValidationException):
     JWTAuthValidator.validate(unvalidated_config, None, None)
 
@@ -31,7 +33,7 @@ def test_invalid_config(unvalidated_config):
   ('invaliduser', 'somepass', ConfigValidationException),
   ('cool.user', 'password', None),
 ])
-def test_validated_jwt(username, password, expected_exception):
+def test_validated_jwt(username, password, expected_exception, app):
   with fake_jwt() as jwt_auth:
     config = {}
     config['AUTHENTICATION_TYPE'] = 'JWT'

util/config/validators/test/test_validate_keystone.py

@@ -6,12 +6,13 @@ from util.morecollections import AttrDict
 
 from test.test_keystone_auth import fake_keystone
 
+from test.fixtures import *
 
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'AUTHENTICATION_TYPE': 'Database'}),
 ])
-def test_validate_noop(unvalidated_config):
+def test_validate_noop(unvalidated_config, app):
   KeystoneValidator.validate(unvalidated_config, None, None)
 
 @pytest.mark.parametrize('unvalidated_config', [
@@ -22,7 +23,7 @@ def test_validate_noop(unvalidated_config):
   ({'AUTHENTICATION_TYPE': 'Keystone', 'KEYSTONE_AUTH_URL': 'foo',
     'KEYSTONE_ADMIN_USERNAME': 'bar', 'KEYSTONE_ADMIN_PASSWORD': 'baz'}),
 ])
-def test_invalid_config(unvalidated_config):
+def test_invalid_config(unvalidated_config, app):
   with pytest.raises(ConfigValidationException):
     KeystoneValidator.validate(unvalidated_config, None, None)
 
@@ -33,7 +34,7 @@ def test_invalid_config(unvalidated_config):
   ('invaliduser', 'somepass', ConfigValidationException),
   ('cool.user', 'password', None),
 ])
-def test_validated_keystone(username, password, expected_exception):
+def test_validated_keystone(username, password, expected_exception, app):
   with fake_keystone(2) as keystone_auth:
     auth_url = keystone_auth.auth_url
 

util/config/validators/test/test_validate_ldap.py

@@ -6,19 +6,20 @@ from util.morecollections import AttrDict
 
 from test.test_ldap import mock_ldap
 
+from test.fixtures import *
 
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'AUTHENTICATION_TYPE': 'Database'}),
 ])
-def test_validate_noop(unvalidated_config):
+def test_validate_noop(unvalidated_config, app):
   LDAPValidator.validate(unvalidated_config, None, None)
 
 @pytest.mark.parametrize('unvalidated_config', [
   ({'AUTHENTICATION_TYPE': 'LDAP'}),
   ({'AUTHENTICATION_TYPE': 'LDAP', 'LDAP_ADMIN_DN': 'foo'}),
 ])
-def test_invalid_config(unvalidated_config):
+def test_invalid_config(unvalidated_config, app):
   with pytest.raises(ConfigValidationException):
     LDAPValidator.validate(unvalidated_config, None, None)
 
@@ -28,7 +29,7 @@ def test_invalid_config(unvalidated_config):
   'http://foo',
   'ldap:foo',
 ])
-def test_invalid_uri(uri):
+def test_invalid_uri(uri, app):
   config = {}
   config['AUTHENTICATION_TYPE'] = 'LDAP'
   config['LDAP_BASE_DN'] = ['dc=quay', 'dc=io']
@@ -47,7 +48,7 @@ def test_invalid_uri(uri):
   ('invaliduser', 'somepass', ConfigValidationException),
   ('someuser', 'somepass', None),
 ])
-def test_validated_ldap(username, password, expected_exception):
+def test_validated_ldap(username, password, expected_exception, app):
   config = {}
   config['AUTHENTICATION_TYPE'] = 'LDAP'
   config['LDAP_BASE_DN'] = ['dc=quay', 'dc=io']

util/config/validators/test/test_validate_oidc.py

@@ -7,19 +7,21 @@ from oauth.oidc import OIDC_WELLKNOWN
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_oidc import OIDCLoginValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({'SOMETHING_LOGIN_CONFIG': {}}),
   ({'SOMETHING_LOGIN_CONFIG': {'OIDC_SERVER': 'foo'}}),
   ({'SOMETHING_LOGIN_CONFIG': {'OIDC_SERVER': 'foo', 'CLIENT_ID': 'foobar'}}),
   ({'SOMETHING_LOGIN_CONFIG': {'OIDC_SERVER': 'foo', 'CLIENT_SECRET': 'foobar'}}),
 ])
-def test_validate_invalid_oidc_login_config(unvalidated_config):
+def test_validate_invalid_oidc_login_config(unvalidated_config, app):
   validator = OIDCLoginValidator()
 
   with pytest.raises(ConfigValidationException):
     validator.validate(unvalidated_config, None, None)
 
-def test_validate_oidc_login():
+def test_validate_oidc_login(app):
   url_hit = [False]
   @urlmatch(netloc=r'someserver', path=r'/\.well-known/openid-configuration')
   def handler(_, __):

util/config/validators/test/test_validate_redis.py

@@ -8,13 +8,15 @@ from mockredis import mock_strict_redis_client
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_redis import RedisValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config,user,user_password,use_mock,expected', [
   ({}, None, None, False, ConfigValidationException),
   ({'BUILDLOGS_REDIS': {}}, None, None, False, ConfigValidationException),
   ({'BUILDLOGS_REDIS': {'host': 'somehost'}}, None, None, False, redis.ConnectionError),
   ({'BUILDLOGS_REDIS': {'host': 'localhost'}}, None, None, True, None),
 ])
-def test_validate_redis(unvalidated_config, user, user_password, use_mock, expected):
+def test_validate_redis(unvalidated_config, user, user_password, use_mock, expected, app):
   with patch('redis.StrictRedis' if use_mock else 'redis.None', mock_strict_redis_client):
     validator = RedisValidator()
     if expected is not None:

util/config/validators/test/test_validate_secscan.py

@@ -4,6 +4,8 @@ from util.config.validators import ConfigValidationException
 from util.config.validators.validate_secscan import SecurityScannerValidator
 from util.secscan.fake import fake_security_scanner
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({'DISTRIBUTED_STORAGE_PREFERENCE': []}),
 ])

util/config/validators/test/test_validate_signer.py

@@ -3,12 +3,14 @@ import pytest
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_signer import SignerValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config,expected', [
   ({}, None),
   ({'SIGNING_ENGINE': 'foobar'}, ConfigValidationException),
   ({'SIGNING_ENGINE': 'gpg2'}, Exception),
 ])
-def test_validate_signer(unvalidated_config,expected):
+def test_validate_signer(unvalidated_config, expected, app):
   validator = SignerValidator()
   if expected is not None:
     with pytest.raises(expected):

util/config/validators/test/test_validate_ssl.py

@@ -7,12 +7,14 @@ from util.config.validators import ConfigValidationException
 from util.config.validators.validate_ssl import SSLValidator, SSL_FILENAMES
 from test.test_ssl_util import generate_test_cert
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config', [
   ({}),
   ({'PREFERRED_URL_SCHEME': 'http'}),
   ({'PREFERRED_URL_SCHEME': 'https', 'EXTERNAL_TLS_TERMINATION': True}),
 ])
-def test_skip_validate_ssl(unvalidated_config):
+def test_skip_validate_ssl(unvalidated_config, app):
   validator = SSLValidator()
   validator.validate(unvalidated_config, None, None)
 
@@ -23,7 +25,7 @@ def test_skip_validate_ssl(unvalidated_config):
   (generate_test_cert(hostname='invalidserver'), ConfigValidationException,
    'Supported names "invalidserver" in SSL cert do not match server hostname "someserver"'),
 ])
-def test_validate_ssl(cert, expected_error, error_message):
+def test_validate_ssl(cert, expected_error, error_message, app):
   with NamedTemporaryFile(delete=False) as cert_file:
     cert_file.write(cert[0])
     cert_file.seek(0)

util/config/validators/test/test_validate_storage.py

@@ -4,13 +4,15 @@ import pytest
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_storage import StorageValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config, expected', [
   ({}, ConfigValidationException),
   ({'DISTRIBUTED_STORAGE_CONFIG': {}}, ConfigValidationException),
   ({'DISTRIBUTED_STORAGE_CONFIG': {'local': None}}, ConfigValidationException),
   ({'DISTRIBUTED_STORAGE_CONFIG': {'local': ['FakeStorage', {}]}}, None),
 ])
-def test_validate_storage(unvalidated_config, expected):
+def test_validate_storage(unvalidated_config, expected, app):
   validator = StorageValidator()
   if expected is not None:
     with pytest.raises(expected):
@@ -18,7 +20,7 @@ def test_validate_storage(unvalidated_config, expected):
   else:
     validator.validate(unvalidated_config, None, None)
 
-def test_validate_s3_storage():
+def test_validate_s3_storage(app):
   validator = StorageValidator()
   with moto.mock_s3():
     with pytest.raises(ConfigValidationException) as ipe:

util/config/validators/test/test_validate_timemachine.py

@@ -4,13 +4,15 @@ from util.config.validators import ConfigValidationException
 from util.config.validators.validate_timemachine import TimeMachineValidator
 from util.morecollections import AttrDict
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('default_exp,options,expected_exception', [
   ('2d', ['1w', '2d'], None),
 
   ('2d', ['1w'], 'Default expiration must be in expiration options set'),
   ('2d', ['2d', '1M'], 'Invalid tag expiration option: 1M'),
 ])
-def test_validate(default_exp, options, expected_exception):
+def test_validate(default_exp, options, expected_exception, app):
   config = {}
   config['DEFAULT_TAG_EXPIRATION'] = default_exp
   config['TAG_EXPIRATION_OPTIONS'] = options

util/config/validators/test/test_validate_torrent.py

@@ -5,11 +5,13 @@ from httmock import urlmatch, HTTMock
 from util.config.validators import ConfigValidationException
 from util.config.validators.validate_torrent import BittorrentValidator
 
+from test.fixtures import *
+
 @pytest.mark.parametrize('unvalidated_config,expected', [
   ({}, ConfigValidationException),
   ({'BITTORRENT_ANNOUNCE_URL': 'http://faketorrent/announce'}, None),
 ])
-def test_validate_torrent(unvalidated_config,expected):
+def test_validate_torrent(unvalidated_config, expected, app):
   announcer_hit = [False]
 
   @urlmatch(netloc=r'faketorrent', path='/announce')