author_email='qa-devel@lists.fedoraproject.org',

        license='GPLv2+',

        packages=['waiverdb'],

  # GNU General Public License for more details.

  #

  import pytest

  from waiverdb.app import create_app, init_db

  @pytest.fixture(scope='session')

  def app(request):

      app = create_app('waiverdb.config.TestingConfig')

      request.addfinalizer(teardown)

      return app

  @pytest.fixture(scope='session')

  def db(app):

      """Session-wide test database."""

      db = init_db(app)

      return db

  @pytest.yield_fixture

  def session(db, monkeypatch):

      """Patch Flask-SQLAlchemy to use a specific connection"""

      transaction.rollback()

      connection.close()

  @pytest.yield_fixture

  def client(app):

      """A Flask test client. An instance of :class:`flask.testing.TestClient`

  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  # GNU General Public License for more details.

  import json

  from .utils import create_waiver

  import datetime

  from mock import patch

  @patch('waiverdb.auth.get_user', return_value=('foo', {}))

  def test_create_waiver(mocked_get_user, client, session, monkeypatch):

      data = {

          'comment': 'it broke',

      }

      r = client.post('/api/v1.0/waivers/', data=json.dumps(data),

      assert r.status_code == 201

      assert res_data['username'] == 'foo'

      assert res_data['result_id'] == 123

      assert res_data['product_version'] == 'fool-1'

      assert res_data['comment'] == 'it broke'

  @patch('waiverdb.auth.get_user', return_value=('foo', {}))

  def test_create_waiver_with_malformed_data(mocked_get_user, client):

      data = {

          'result_id': 'wrong id',

      }

      r = client.post('/api/v1.0/waivers/', data=json.dumps(data),

      assert r.status_code == 400

      assert 'invalid literal for int()' in res_data['message']['result_id']

  def test_get_waiver(client, session):

      # create a new waiver

      waiver = create_waiver(session, result_id=123, username='foo',

      r = client.get('/api/v1.0/waivers/%s' % waiver.id)

      assert r.status_code == 200

      assert res_data['username'] == waiver.username

      assert res_data['result_id'] == waiver.result_id

      assert res_data['product_version'] == waiver.product_version

      assert res_data['comment'] == waiver.comment

  def test_404_for_nonexistent_waiver(client, session):

      r = client.get('/api/v1.0/waivers/foo')

      assert r.status_code == 404

  def test_get_waivers(client, session):

          create_waiver(session, result_id=i, username='foo %d' % i,

      r = client.get('/api/v1.0/waivers/')

      assert r.status_code == 200

      assert len(res_data['data']) == 10

  def test_pagination_waivers(client, session):

          create_waiver(session, result_id=i, username='foo %d' % i,

      assert r.status_code == 200

  def test_obsolete_waivers_are_excluded_by_default(client, session):

      new_waiver = create_waiver(session, result_id=123, username='foo',

      r = client.get('/api/v1.0/waivers/')

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['id'] == new_waiver.id

      assert res_data['data'][0]['waived'] == new_waiver.waived

  def test_get_obsolete_waivers(client, session):

      old_waiver = create_waiver(session, result_id=123, username='foo',

      new_waiver = create_waiver(session, result_id=123, username='foo',

      r = client.get('/api/v1.0/waivers/?include_obsolete=1')

      assert r.status_code == 200

      assert len(res_data['data']) == 2

  def test_filtering_waivers_by_result_id(client, session):

      create_waiver(session, result_id=123, username='foo-1', product_version='foo-1')

      create_waiver(session, result_id=234, username='foo-2', product_version='foo-1')

      r = client.get('/api/v1.0/waivers/?result_id=123')

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['result_id'] == 123

  def test_filtering_waivers_by_product_version(client, session):

      create_waiver(session, result_id=123, username='foo-1', product_version='release-1')

      create_waiver(session, result_id=124, username='foo-1', product_version='release-2')

      r = client.get('/api/v1.0/waivers/?product_version=release-1')

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['product_version'] == 'release-1'

  def test_filtering_waivers_by_username(client, session):

      create_waiver(session, result_id=123, username='foo', product_version='foo-1')

      create_waiver(session, result_id=124, username='bar', product_version='foo-2')

      r = client.get('/api/v1.0/waivers/?username=foo')

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['username'] == 'foo'

  def test_filtering_waivers_by_since(client, session):

      before1 = (datetime.datetime.utcnow() - datetime.timedelta(seconds=100)).isoformat()

      before2 = (datetime.datetime.utcnow() - datetime.timedelta(seconds=99)).isoformat()

      after = (datetime.datetime.utcnow() + datetime.timedelta(seconds=100)).isoformat()

      create_waiver(session, result_id=123, username='foo', product_version='foo-1')

      r = client.get('/api/v1.0/waivers/?since=%s' % before1)

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['result_id'] == 123

      r = client.get('/api/v1.0/waivers/?since=%s,%s' % (before1, after))

      assert r.status_code == 200

      assert len(res_data['data']) == 1

      assert res_data['data'][0]['result_id'] == 123

      r = client.get('/api/v1.0/waivers/?since=%s' % (after))

      assert r.status_code == 200

      assert len(res_data['data']) == 0

      r = client.get('/api/v1.0/waivers/?since=%s,%s' % (before1, before2))

      assert r.status_code == 200

      assert len(res_data['data']) == 0

  def test_jsonp(client, session):

      waiver = create_waiver(session, result_id=123, username='foo', product_version='foo-1')

      r = client.get('/api/v1.0/waivers/%s?callback=jsonpcallback' % waiver.id)

      assert r.mimetype == 'application/javascript'

  from werkzeug.exceptions import Unauthorized

  import waiverdb.auth

  class TestKerberosAuthentication(object):

      def test_keytab_file_is_not_set_should_raise_error(self):

      @mock.patch('kerberos.authGSSServerClean')

      @mock.patch('kerberos.getServerPrincipalDetails')

      def test_authorized(self, principal, clean, name, response, step, init,

          monkeypatch.setenv('KRB5_KTNAME', '/etc/foo.keytab')

          data = {

              'result_id': 123,

              'comment': 'it broke',

          }

          r = client.post('/api/v1.0/waivers/',  data=json.dumps(data),

          assert r.status_code == 201

          assert r.headers.get('WWW-Authenticate') == 'negotiate STOKEN'

          assert res_data['username'] == 'foo'

  from waiverdb.models import Waiver

  def create_waiver(session, result_id, username, product_version, waived=True,

      waiver = Waiver(result_id, username, product_version, waived, comment)

      session.add(waiver)

      session.flush()

  from flask import Blueprint, request

  from flask_restful import Resource, Api, reqparse, marshal_with

  from sqlalchemy.sql.expression import func

  from waiverdb.models import db, Waiver

  RP['get_waivers'].add_argument('page', default=1, type=int, location='args')

  RP['get_waivers'].add_argument('limit', default=10, type=int, location='args')

  class WaiversResource(Resource):

      @jsonp

      def get(self):

          user, headers = waiverdb.auth.get_user(request)

          args = RP['create_waiver'].parse_args()

          waiver = Waiver(args['result_id'], user, args['product_version'], args['waived'],

          db.session.add(waiver)

          db.session.commit()

          return waiver, 201, headers

          except:

              raise NotFound('Waiver not found')

  # set up the Api resource routing here

  api.add_resource(WaiversResource, '/waivers/')

  api.add_resource(WaiverResource, '/waivers/<int:waiver_id>')

  import os

  from flask import Flask

  from waiverdb.logger import init_logging

  from waiverdb.api_v1 import api_v1

  from waiverdb.models import db

  def load_default_config(app):

      # Load default config, then override that with a config file

      if os.getenv('DEV') == 'true':

      if os.path.exists(config_file):

          app.config.from_pyfile(config_file)

  # applicaiton factory http://flask.pocoo.org/docs/0.12/patterns/appfactories/

  def create_app(config_obj=None):

      app = Flask(__name__)

      app.register_blueprint(api_v1, url_prefix="/api/v1.0")

      return app

  def init_db(app):

      with app.app_context():

          db.create_all()

  from socket import gethostname

  from werkzeug.exceptions import Unauthorized, Forbidden

  class KerberosAuthenticate(object):

      def __init__(self):

              raise Forbidden("Invalid Kerberos ticket")

          return kerberos_user, kerberos_token

  def get_user(request):

      user = None

      headers = dict()

  import logging

  import sys

  def log_to_stdout(app, level=logging.INFO):

      fmt = '[%(filename)s:%(lineno)d] ' if app.debug else '%(module)-12s '

      fmt += '%(asctime)s %(levelname)-7s %(message)s'

      stream_handler.setFormatter(logging.Formatter(fmt=fmt, datefmt=datefmt))

      app.logger.addHandler(stream_handler)

  def log_to_journal(app, level=logging.INFO):

      try:

          import systemd.journal

      journal_handler.setLevel(level)

      app.logger.addHandler(journal_handler)

  def init_logging(app):

      log_level = logging.DEBUG if app.debug else logging.INFO

      if app.config['JOURNAL_LOGGING']:

  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  # GNU General Public License for more details.

  import datetime

  from .base import db

  class Waiver(db.Model):

      id = db.Column(db.Integer, primary_key=True)

      result_id = db.Column(db.Integer, nullable=False)

  from waiverdb.fields import waiver_fields

  from werkzeug.exceptions import NotFound

  def reqparse_since(since):

      """

      This parses the since(i.e. 2017-02-13T23:37:58.193281, 2017-02-16T23:37:58.193281)

          end = datetime.datetime.strptime(end, "%Y-%m-%dT%H:%M:%S.%f")

      return start, end

  def json_collection(query, page=1, limit=10):

      """

      a collection of resources as JSON.

      """

      try:

          p = query.paginate(page, limit)

      except NotFound:

      pages = {'data': marshal(p.items, waiver_fields)}

      query_pairs = request.args.copy()

      if query_pairs:

          query_pairs.pop('page', default=None)

      if p.has_prev:

          pages['prev'] = url_for(request.endpoint, page=p.prev_num, _external=True,

      else:

          pages['prev'] = None

      if p.has_next:

          pages['next'] = url_for(request.endpoint, page=p.next_num, _external=True,

      else:

          pages['next'] = None

      pages['first'] = url_for(request.endpoint, page=1, _external=True, **query_pairs)

      pages['last'] = url_for(request.endpoint, page=p.pages, _external=True, **query_pairs)

      return pages

  def jsonp(func):

      """Wraps Jsonified output for JSONP requests."""

      @functools.wraps(func)