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

      data = {

          'result_id': 123,

          'product_version': 'fool-1',

      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',

      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)

              'id': waiver.id,

              'result_id': 1,

              'username': 'jcline',

              'product_version': 'something',

              'waived': True,

              'comment': 'This is a comment',

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

      session.add(waiver)

      session.flush()

      return waiver

  from flask import Blueprint, request, current_app

  from flask_restful import Resource, Api, reqparse, marshal_with, marshal

  from sqlalchemy.sql.expression import func

  from waiverdb import __version__

  RP['create_waiver'].add_argument('waived', type=bool, required=True, location='json')

  RP['create_waiver'].add_argument('product_version', type=str, required=True, location='json')

  RP['create_waiver'].add_argument('comment', type=str, default=None, location='json')

  RP['get_waivers'] = reqparse.RequestParser()

  RP['get_waivers'].add_argument('result_id', location='args')

  RP['get_waivers'].add_argument('since', location='args')

  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):

              more result IDs separated by commas.

          :query string product_version: Filter the waivers by product version.

          :query string username: Filter the waivers by username.

          :query string since: An ISO 8601 formatted datetime (e.g. 2017-03-16T13:40:05+00:00)

              to filter results by. Optionally provide a second ISO 8601 datetime separated

              by a comma to retrieve a range (e.g. 2017-03-16T13:40:05+00:00,

              query = query.filter(Waiver.product_version == args['product_version'])

          if args['username']:

              query = query.filter(Waiver.username == args['username'])

          if args['since']:

              try:

                  since_start, since_end = reqparse_since(args['since'])

                 "result_id": 1,

                 "timestamp": "2017-03-16T17:42:04.209638",

                 "username": "jcline",

             }

          :json int result_id: The result ID for the waiver.

          :json boolean waived: Whether or not the result is waived.

          :json string product_version: The product version string.

          :json string comment: A comment explaining the waiver.

          :statuscode 201: The waiver was successfully created.

          """

          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

                          "result_id": 2,

                          "timestamp": "2017-09-21T04:55:53.343368",

                          "username": "dummy",

                      },

                      {

                          "comment": "It's dead!",

                          "result_id": 1,

                          "timestamp": "2017-09-21T04:55:51.936658",

                          "username": "dummy",

                      }

                  ]

              }

          :jsonparam array result_ids: Filter the waivers by a list of result IDs.

          :jsonparam string product_version: Filter the waivers by product version.

          :jsonparam string username: Filter the waivers by username.

          :jsonparam string since: An ISO 8601 formatted datetime (e.g. 2017-03-16T13:40:05+00:00)

              to filter results by. Optionally provide a second ISO 8601 datetime separated

              by a comma to retrieve a range (e.g. 2017-03-16T13:40:05+00:00,

              query = query.filter(Waiver.product_version == data['product_version'])

          if 'username' in data:

              query = query.filter(Waiver.username == data['username'])

          if 'since' in data:

              try:

                  since_start, since_end = reqparse_since(data['since'])

      # Specify fedmsg or stomp for publishing messages

      MESSAGE_PUBLISHER = 'fedmsg'

      SQLALCHEMY_TRACK_MODIFICATIONS = True

  class ProductionConfig(Config):

      )

      OIDC_REQUIRED_SCOPE = 'waiverdb_scope'

      OIDC_RESOURCE_SERVER_ONLY = True

              "timestamp": "2017-03-16T17:42:04.209638",

              "product_version": "Satellite 6.3",

              "result_id": 1,

              "id": 15

            }

          }

      'id': fields.Integer,

      'result_id': fields.Integer,

      'username': fields.String,

      'product_version': fields.String,

      'waived': fields.Boolean,

      'comment': fields.String,

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

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

      username = db.Column(db.String(255), nullable=False)

      product_version = db.Column(db.String(200), nullable=False)

      waived = db.Column(db.Boolean, nullable=False, default=False)

      comment = db.Column(db.Text)

      timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow)

          self.result_id = result_id

          self.username = username

          self.product_version = product_version

          self.waived = waived

          self.comment = comment

      def __repr__(self):

          return '%s(result_id=%r, username=%r, product_version=%r, waived=%r)' % \