def test_basic_search(app, db, es):
    """Test basic search functionality."""
    # The index should be empty
    assert len(ItemSearch().execute()) == 0

    # Create item1, search for everything
    item1 = Item.create({})
    item1.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item1)

    current_search.flush_and_refresh('_all')

    assert len(ItemSearch().execute()) == 1

    # Create item2, search for everything again
    item2 = Item.create({'foo': 'bar'})
    item2.commit()
    record_indexer.index(item2)

    current_search.flush_and_refresh('_all')

    assert len(ItemSearch().execute()) == 2

    # Search for item2
    assert len(ItemSearch().query('match', foo='bar').execute()) == 1

    # Search for nonsense
    assert len(ItemSearch().query('match', foo='banana').execute()) == 0
Example #2
0
def test_loan_return_receiver(app, db, access_token):
    """Use the webhooks api to loan and return an item."""
    item_uuid = uuid.uuid4()
    item_data = {}
    pid = circulation_item_minter(item_uuid, item_data)
    item = Item.create(item_data, id_=item_uuid)
    with app.test_request_context():
        with app.test_client() as client:
            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_loan')
            url += '?access_token=' + access_token
            data = {'item_id': pid.pid_value}
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 202

            item = Item.get_record(item.id)
            assert item['_circulation']['status'] == ItemStatus.ON_LOAN
            assert len(item['_circulation']['holdings']) == 1

            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_return')
            url += '?access_token=' + access_token
            data = {'item_id': pid.pid_value}
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 202

            item = Item.get_record(item.id)
            assert item['_circulation']['status'] == ItemStatus.ON_SHELF
            assert len(item['_circulation']['holdings']) == 0
def test_basic_search(app, db, es):
    """Test basic search functionality."""
    # The index should be empty
    assert len(ItemSearch().execute()) == 0

    # Create item1, search for everything
    item1 = Item.create({})
    item1.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item1)

    current_search.flush_and_refresh('_all')

    assert len(ItemSearch().execute()) == 1

    # Create item2, search for everything again
    item2 = Item.create({'foo': 'bar'})
    item2.commit()
    record_indexer.index(item2)

    current_search.flush_and_refresh('_all')

    assert len(ItemSearch().execute()) == 2

    # Search for item2
    assert len(ItemSearch().query('match', foo='bar').execute()) == 1

    # Search for nonsense
    assert len(ItemSearch().query('match', foo='banana').execute()) == 0
def test_item_find_by_holding(app, db, arguments, assertions):
    # Prepare the item
    item = Item.create({})
    db.session.commit()

    # Create loan data
    la = LoanItemSchema()
    la.context['item'] = item

    # Prepare the loan data
    data = []
    tmp = la.load({'user_id': 1}).data
    data.append(la.dump(tmp).data)

    end_date = datetime.date.today() + datetime.timedelta(weeks=2)
    tmp = la.load({'user_id': 2, 'end_date': end_date}).data
    data.append(la.dump(tmp).data)

    for d in data:
        # Loan item
        item.loan_item(**d)
        item.commit()
        db.session.commit()

        # Return item
        item.return_item()
        item.commit()
        db.session.commit()

    res = list(Item.find_by_holding(**arguments))
    for assertion in assertions:
        assert assertion(res, item)
def test_item_find_by_holding(app, db, arguments, assertions):
    # Prepare the item
    item = Item.create({})
    db.session.commit()

    # Create loan data
    la = LoanItemSchema()
    la.context['item'] = item

    # Prepare the loan data
    data = []
    tmp = la.load({'user_id': 1}).data
    data.append(la.dump(tmp).data)

    end_date = datetime.date.today() + datetime.timedelta(weeks=2)
    tmp = la.load({'user_id': 2, 'end_date': end_date}).data
    data.append(la.dump(tmp).data)

    for d in data:
        # Loan item
        item.loan_item(**d)
        item.commit()
        db.session.commit()

        # Return item
        item.return_item()
        item.commit()
        db.session.commit()

    res = list(Item.find_by_holding(**arguments))
    for assertion in assertions:
        assert assertion(res, item)
Example #6
0
def test_extend_receiver(app, db, access_token):
    """Use the webhooks api to an item loan."""
    item_uuid = uuid.uuid4()
    item_data = {}
    pid = circulation_item_minter(item_uuid, item_data)
    item = Item.create(item_data, id_=item_uuid)
    with app.test_request_context():
        with app.test_client() as client:
            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_loan')
            url += '?access_token=' + access_token
            data = {'item_id': pid.pid_value}
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 202

            item = Item.get_record(item.id)
            assert item['_circulation']['status'] == ItemStatus.ON_LOAN

            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_extend')
            url += '?access_token=' + access_token
            data = {
                'item_id': pid.pid_value,
                'requested_end_date': datetime.date.today().isoformat(),
            }
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 202

            item = Item.get_record(item.id)
            assert item['_circulation']['status'] == ItemStatus.ON_LOAN
def test_item_find_by_holding_value_error(app, db):
    # Raises for less than two values
    with pytest.raises(ValueError):
        list(Item.find_by_holding(start_date=[1]))

    # Raises for three or more values
    with pytest.raises(ValueError):
        list(Item.find_by_holding(start_date=[1, 2, 3]))
def test_item_find_by_holding_value_error(app, db):
    # Raises for less than two values
    with pytest.raises(ValueError):
        list(Item.find_by_holding(start_date=[1]))

    # Raises for three or more values
    with pytest.raises(ValueError):
        list(Item.find_by_holding(start_date=[1, 2, 3]))
Example #9
0
def test_holdings(app, db):
    """Test basic Item.holdings functionality."""
    item = Item.create({})

    assert not item.holdings

    # Append an item

    id1 = str(uuid.uuid4())
    holding = Holding.create(id_=id1)

    item.holdings.append(holding)
    assert len(item.holdings) == 1
    assert id1 in item.holdings

    # Insert an item

    id2 = str(uuid.uuid4())
    holding = Holding.create(id_=id2)

    item.holdings.insert(0, holding)
    assert len(item.holdings) == 2
    assert [id2, id1] == [x['id'] for x in item.holdings]

    # Delete an item

    del item.holdings[id2]
    assert len(item.holdings) == 1
    assert id2 not in item.holdings
    assert id1 in item.holdings
def test_item_request(app, db):
    item = Item.create({})

    # Request the item
    item.request_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 1
def test_loan_item_marshmallow(app, db):
    """Use LoanItemSchema to validate loan_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = LoanItemSchema()
    circulation_event_schema.context['item'] = item

    # Valid arguments
    assert not circulation_event_schema.validate({})
    assert not circulation_event_schema.validate({
        'start_date': datetime.date.today(),
        'end_date':  datetime.date.today() + datetime.timedelta(weeks=4),
    })

    # Invalid start date
    errors = circulation_event_schema.validate({
        'start_date': datetime.date.today() + datetime.timedelta(days=1),
        'end_date':  datetime.date.today() + datetime.timedelta(weeks=4),
    })
    assert 'start_date' in errors

    # Invalid duration
    errors = circulation_event_schema.validate({
        'start_date': datetime.date.today(),
        'end_date':  datetime.date.today() + datetime.timedelta(weeks=5),
    })
    assert '_schema' in errors

    # Invalid item status
    item['_circulation']['status'] = 'foo'
    circulation_event_schema.context['item'] = item

    errors = circulation_event_schema.validate({})
    assert '_schema' in errors
def test_holdings(app, db):
    """Test basic Item.holdings functionality."""
    item = Item.create({})

    assert not item.holdings

    # Append an item

    id1 = str(uuid.uuid4())
    holding = Holding.create(id_=id1)

    item.holdings.append(holding)
    assert len(item.holdings) == 1
    assert id1 in item.holdings

    # Insert an item

    id2 = str(uuid.uuid4())
    holding = Holding.create(id_=id2)

    item.holdings.insert(0, holding)
    assert len(item.holdings) == 2
    assert [id2, id1] == [x['id'] for x in item.holdings]

    # Delete an item

    del item.holdings[id2]
    assert len(item.holdings) == 1
    assert id2 not in item.holdings
    assert id1 in item.holdings
def test_item_request(app, db):
    item = Item.create({})

    # Request the item
    item.request_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 1
def test_item_extend_loan(app, db):
    item = Item.create({})

    # Loan the item
    item.loan_item()

    # Extend the loan
    item.extend_loan()
    assert item['_circulation']['status'] == ItemStatus.ON_LOAN
def test_item_extend_loan(app, db):
    item = Item.create({})

    # Loan the item
    item.loan_item()

    # Extend the loan
    item.extend_loan()
    assert item['_circulation']['status'] == ItemStatus.ON_LOAN
Example #16
0
def test_circulation_fetcher(db):
    """Test circulation_item_fetcher functionality."""
    item = Item.create({'foo': 'bar'})
    pid = circulation_item_minter(item.id, item)

    item.commit()
    db.session.commit()

    fetched = circulation_item_fetcher(item.id, item)

    assert pid.pid_value == fetched.pid_value
def test_blocking_holds(app, db, request_arguments, validate_arguments,
                        assert_statement):
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = RequestItemSchema()
    circulation_event_schema.context['item'] = item

    item.request_item(**RequestItemSchema().dump(request_arguments).data)
    item.commit()
    errors = circulation_event_schema.validate(validate_arguments)
    assert assert_statement(errors)
def test_cancel_hold(app, db):
    item = Item.create({})

    # Loan the item
    item.request_item()

    item.cancel_hold(item['_circulation']['holdings'][0]['id'])

    assert len(item['_circulation']['holdings']) == 0

    with pytest.raises(Exception):
        item.cancel_hold(1)
def test_cancel_hold(app, db):
    item = Item.create({})

    # Loan the item
    item.request_item()

    item.cancel_hold(item['_circulation']['holdings'][0]['id'])

    assert len(item['_circulation']['holdings']) == 0

    with pytest.raises(Exception):
        item.cancel_hold(1)
Example #20
0
def test_dry_run(app, db, access_token):
    """Use the webhooks api to loan and return an item."""
    item_uuid = uuid.uuid4()
    item_data = {}
    pid = circulation_item_minter(item_uuid, item_data)
    item = Item.create(item_data, id_=item_uuid)
    with app.test_request_context():
        with app.test_client() as client:
            # Successful request
            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_loan')
            url += '?access_token=' + access_token
            data = {
                'item_id': pid.pid_value,
                'dry_run': True,
            }
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 204

            item = Item.get_record(item.id)
            assert item['_circulation']['status'] == ItemStatus.ON_SHELF
            assert len(item['_circulation']['holdings']) == 0

            # Invalid request
            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_loan')
            url += '?access_token=' + access_token
            yesterday = datetime.date.today() + datetime.timedelta(days=-1)
            data = {
                'item_id': pid.pid_value,
                'start_date': str(yesterday),
                'dry_run': True,
            }
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 400
def test_blocking_holds(app, db,
                        request_arguments,
                        validate_arguments,
                        assert_statement):
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = RequestItemSchema()
    circulation_event_schema.context['item'] = item

    item.request_item(**RequestItemSchema().dump(request_arguments).data)
    item.commit()
    errors = circulation_event_schema.validate(validate_arguments)
    assert assert_statement(errors)
def test_return_missing_item_marshmallow(app, db):
    """Use LoanItemSchema to validate return_missing_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ReturnMissingItemSchema()
    circulation_event_schema.context['item'] = item

    # Item not missing
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors

    item.lose_item()
    assert not circulation_event_schema.validate({})
def test_return_missing_item_marshmallow(app, db):
    """Use LoanItemSchema to validate return_missing_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ReturnMissingItemSchema()
    circulation_event_schema.context['item'] = item

    # Item not missing
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors

    item.lose_item()
    assert not circulation_event_schema.validate({})
def test_request_item_marshmallow(app, db):
    """Use LoanItemSchema to validate request_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = RequestItemSchema()
    circulation_event_schema.context['item'] = item

    # Valid arguments
    assert not circulation_event_schema.validate({})
    assert not circulation_event_schema.validate(
        {
            'start_date': datetime.date.today(),
            'end_date': datetime.date.today() + datetime.timedelta(weeks=4),
        })

    # Valid arguments date in the future
    errors = circulation_event_schema.validate({
        'start_date':
        datetime.date.today() + datetime.timedelta(days=1),
        'end_date':
        datetime.date.today() + datetime.timedelta(weeks=4),
    })
    assert not errors

    # Invalid start date
    errors = circulation_event_schema.validate({
        'start_date':
        datetime.date.today() + datetime.timedelta(days=-1),
        'end_date':
        datetime.date.today() + datetime.timedelta(weeks=4),
    })
    assert 'start_date' in errors

    # Invalid duration
    errors = circulation_event_schema.validate({
        'start_date':
        datetime.date.today(),
        'end_date':
        datetime.date.today() + datetime.timedelta(weeks=5),
    })
    assert '_schema' in errors

    # Invalid item status
    item['_circulation']['status'] = ItemStatus.MISSING
    circulation_event_schema.context['item'] = item

    errors = circulation_event_schema.validate({})
    assert '_schema' in errors
def test_extend_loan_marshmallow(app, db):
    """Use LoanItemSchema to validate extend_loan parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ExtendItemSchema()
    circulation_event_schema.context['item'] = item

    # Valid arguments
    assert not circulation_event_schema.validate({})

    # Date too far in the future
    requested_end_date = datetime.date.today() + datetime.timedelta(weeks=5)
    errors = circulation_event_schema.validate(
        {'requested_end_date': requested_end_date})
    assert '_schema' in errors
Example #26
0
def test_holding_values(app, db, action, schema):
    """Test holding values exist for loan_item/request_item."""
    # Loan an item
    item = Item.create({})

    assert not item.holdings

    action(item, schema().dump({}).data)
    item.commit()

    holding = item.holdings[0]
    assert len(item.holdings) == 1
    assert 'start_date' in holding
    assert 'end_date' in holding
    assert 'waitlist' in holding
    assert 'delivery' in holding
    assert 'user_id' in holding
def test_extend_loan_marshmallow(app, db):
    """Use LoanItemSchema to validate extend_loan parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ExtendItemSchema()
    circulation_event_schema.context['item'] = item

    # Valid arguments
    assert not circulation_event_schema.validate({})

    # Date too far in the future
    requested_end_date = datetime.date.today() + datetime.timedelta(weeks=5)
    errors = circulation_event_schema.validate({
        'requested_end_date': requested_end_date
    })
    assert '_schema' in errors
def test_cancel_item_marshmallow(app, db):
    """Use LoanItemSchema to validate cancel_hold parameters."""
    item = Item.create({})
    item.loan_item()
    db.session.commit()

    hold_id = item.holdings[0]['id']

    circulation_event_schema = CancelItemSchema()
    circulation_event_schema.context['item'] = item

    # No existing UUID
    errors = circulation_event_schema.validate({'hold_id': str(uuid.uuid4())})
    assert '_schema' in errors

    # Valid argument
    assert not circulation_event_schema.validate({'hold_id': str(hold_id)})
def test_holding_values(app, db, action, schema):
    """Test holding values exist for loan_item/request_item."""
    # Loan an item
    item = Item.create({})

    assert not item.holdings

    action(item, schema().dump({}).data)
    item.commit()

    holding = item.holdings[0]
    assert len(item.holdings) == 1
    assert 'start_date' in holding
    assert 'end_date' in holding
    assert 'waitlist' in holding
    assert 'delivery' in holding
    assert 'user_id' in holding
def test_item_lose(app, db):
    item = Item.create({})

    # Lose the item
    item.lose_item()
    assert item['_circulation']['status'] == ItemStatus.MISSING

    # Return missing item
    item.return_missing_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF

    # Request the item
    item.request_item()

    # Lose the item
    item.lose_item()
    assert item['_circulation']['status'] == ItemStatus.MISSING
    assert len(item['_circulation']['holdings']) == 0
def test_item_lose(app, db):
    item = Item.create({})

    # Lose the item
    item.lose_item()
    assert item['_circulation']['status'] == ItemStatus.MISSING

    # Return missing item
    item.return_missing_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF

    # Request the item
    item.request_item()

    # Lose the item
    item.lose_item()
    assert item['_circulation']['status'] == ItemStatus.MISSING
    assert len(item['_circulation']['holdings']) == 0
def test_return_item_marshmallow(app, db):
    """Use LoanItemSchema to validate return_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ReturnItemSchema()
    circulation_event_schema.context['item'] = item

    # No item to return arguments
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors

    # No active hold
    item.request_item(**RequestItemSchema().dump({
        'start_date': datetime.date.today() + datetime.timedelta(weeks=1),
    }).data)
    item.commit()
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors
def test_item_circulation_loan(app, db):
    item = Item.create({})

    # Loan the item
    item.loan_item()
    assert item['_circulation']['status'] == ItemStatus.ON_LOAN
    assert len(item['_circulation']['holdings']) == 1

    # Return the item
    item.return_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 0

    # Loan the item
    item.loan_item()

    # Loan again
    with pytest.raises(PIDInvalidAction):
        item.loan_item(1)
def test_item_circulation_loan(app, db):
    item = Item.create({})

    # Loan the item
    item.loan_item()
    assert item['_circulation']['status'] == ItemStatus.ON_LOAN
    assert len(item['_circulation']['holdings']) == 1

    # Return the item
    item.return_item()
    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 0

    # Loan the item
    item.loan_item()

    # Loan again
    with pytest.raises(PIDInvalidAction):
        item.loan_item(1)
def test_crud_read(app, db, es):
    """Test REST API get functionality."""
    item = Item.create({'foo': 'bar'})
    circulation_item_minter(item.id, item)
    item.commit()
    db.session.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item)

    current_search.flush_and_refresh('_all')

    with app.test_request_context():
        with app.test_client() as client:
            url = url_for('circulation_rest.crcitm_item',
                          pid_value=item['control_number'])
            res = client.get(url)
            fetched_item = json.loads(res.data.decode('utf-8'))['metadata']

            assert fetched_item['control_number'] == item['control_number']
def test_crud_read(app, db, es):
    """Test REST API get functionality."""
    item = Item.create({'foo': 'bar'})
    circulation_item_minter(item.id, item)
    item.commit()
    db.session.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item)

    current_search.flush_and_refresh('_all')

    with app.test_request_context():
        with app.test_client() as client:
            url = url_for('circulation_rest.crcitm_item',
                          pid_value=item['control_number'])
            res = client.get(url)
            fetched_item = json.loads(res.data.decode('utf-8'))['metadata']

            assert fetched_item['control_number'] == item['control_number']
def test_rest_search(app, db, es, url_addition, count):
    """Test REST API search functionality."""
    item = Item.create({'foo': 'bar'})
    circulation_item_minter(item.id, item)
    item.commit()
    db.session.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item)

    current_search.flush_and_refresh('_all')

    with app.test_request_context():
        with app.test_client() as client:
            base_url = url_for('circulation_rest.crcitm_list')
            url = base_url + url_addition

            res = client.get(url)
            hits = json.loads(res.data.decode('utf-8'))['hits']['hits']
            assert len(hits) == count
Example #38
0
def items():
    """Create circulation items."""
    from invenio_db import db
    from invenio_indexer.api import RecordIndexer

    from invenio_circulation.api import Item
    from invenio_circulation.minters import circulation_item_minter

    for x in range(10):
        item = Item.create({
            'foo': 'bar{0}'.format(x),
            'title_statement': {'title': 'title{0}'.format(x)},
            'record': {'id': 1}
        })
        circulation_item_minter(item.id, item)
        item.commit()
        record_indexer = RecordIndexer()
        record_indexer.index(item)

    db.session.commit()
Example #39
0
def test_receiver_base(app, db, access_token):
    """Test ReceiverBase failure behavior."""
    item_uuid = uuid.uuid4()
    item_data = {}
    pid = circulation_item_minter(item_uuid, item_data)
    item = Item.create(item_data, id_=item_uuid)
    with app.test_request_context():
        with app.test_client() as client:
            url = url_for('invenio_webhooks.event_list',
                          receiver_id='circulation_loan')
            url += '?access_token=' + access_token
            yesterday = datetime.date.today() + datetime.timedelta(days=-1)
            data = {
                'item_id': pid.pid_value,
                'start_date': str(yesterday),
            }
            res = client.post(url, data=json.dumps(data),
                              content_type='application/json')

            assert res.status_code == 400
def test_return_item_marshmallow(app, db):
    """Use LoanItemSchema to validate return_item parameters."""
    item = Item.create({})
    db.session.commit()

    circulation_event_schema = ReturnItemSchema()
    circulation_event_schema.context['item'] = item

    # No item to return arguments
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors

    # No active hold
    item.request_item(**RequestItemSchema().dump({
        'start_date':
        datetime.date.today() + datetime.timedelta(weeks=1),
    }).data)
    item.commit()
    errors = circulation_event_schema.validate({})
    assert '_schema' in errors
def test_rest_search(app, db, es, url_addition, count):
    """Test REST API search functionality."""
    item = Item.create({'foo': 'bar'})
    circulation_item_minter(item.id, item)
    item.commit()
    db.session.commit()

    record_indexer = RecordIndexer()
    record_indexer.index(item)

    current_search.flush_and_refresh('_all')

    with app.test_request_context():
        with app.test_client() as client:
            base_url = url_for('circulation_rest.crcitm_list')
            url = base_url + url_addition

            res = client.get(url)
            hits = json.loads(res.data.decode('utf-8'))['hits']['hits']
            assert len(hits) == count
def test_cancel_item_marshmallow(app, db):
    """Use LoanItemSchema to validate cancel_hold parameters."""
    item = Item.create({})
    item.loan_item()
    db.session.commit()

    hold_id = item.holdings[0]['id']

    circulation_event_schema = CancelItemSchema()
    circulation_event_schema.context['item'] = item

    # No existing UUID
    errors = circulation_event_schema.validate({
        'hold_id': str(uuid.uuid4())
    })
    assert '_schema' in errors

    # Valid argument
    assert not circulation_event_schema.validate({
        'hold_id': str(hold_id)
    })
def test_item_create(app, db):
    item = Item.create({})

    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 0
def test_item_create(app, db):
    item = Item.create({})

    assert item['_circulation']['status'] == ItemStatus.ON_SHELF
    assert len(item['_circulation']['holdings']) == 0