def test_query_delete_entries_propagated_from_nested_qs(self):
item_1 = MockModel(foo=1, bar='a', mock_name='item_1')
item_2 = MockModel(foo=1, bar='b', mock_name='item_2')
self.mock_set.add(item_1, item_2)
self.mock_set.filter(bar='b').delete()
assert len(self.mock_set) == 1, len(self.mock_set)
assert item_1 in self.mock_set
assert item_2 not in self.mock_set
def test_query_get_or_create_gets_existing_unique_match(self):
item_1 = MockModel(foo=1)
item_2 = MockModel(foo=2)
item_3 = MockModel(foo=3)
self.mock_set.add(item_1, item_2, item_3)
obj, created = self.mock_set.get_or_create(foo=2)
assert obj == item_2
assert created is False
def test_query_removes_items_from_set(self):
item_1 = MockModel(foo=1)
item_2 = MockModel(foo=2)
self.mock_set.add(item_1, item_2)
self.mock_set.remove(foo=1)
items = list(self.mock_set)
assert item_1 not in items
assert item_2 in items
def test_query_update_or_create_raises_does_multiple_objects_returned_when_more_than_one_match(
self):
item_1 = MockModel(foo=1)
item_2 = MockModel(foo=1)
item_3 = MockModel(foo=2)
self.mock_set.add(item_1, item_2, item_3)
self.assertRaises(MultipleObjectsReturned,
self.mock_set.update_or_create,
foo=1)
def test_query_latest_returns_the_last_element_from_ordered_set_using_field_name_kwarg(
self):
item_1 = MockModel(foo=1)
item_2 = MockModel(foo=2)
item_3 = MockModel(foo=3)
self.mock_set.add(item_3, item_1, item_2)
latest = self.mock_set.latest(field_name='foo')
assert latest == item_3
def test_query_return_self_methods_accept_any_parameters_and_return_instance(
self):
qs = MockSet(MockModel(foo=1), MockModel(foo=2))
assert qs == qs.all()
assert qs == qs.only('f1')
assert qs == qs.defer('f2', 'f3')
assert qs == qs.using('default')
assert qs == qs.select_related('t1', 't2')
assert qs == qs.prefetch_related('t3', 't4')
assert qs == qs.select_for_update()
def test_query_update_with_multiple_values(self):
objects = [MockModel(foo=1), MockModel(foo=2), MockModel(foo=3)]
qs = MockSet(*objects, model=create_model('foo', 'bar'))
set_foo, set_bar = 4, 5
qs.update(foo=set_foo, bar=set_bar)
for x in qs:
assert x.foo == set_foo, x.foo
assert x.bar == set_bar, x.bar
def test_query_update_or_create_raises_model_not_specified_with_defaults_when_mockset_model_is_none(
self):
qs = MockSet()
item_1 = MockModel(first=1)
item_2 = MockModel(second=2)
item_3 = MockModel(third=3)
qs.add(item_1, item_2, item_3)
with self.assertRaises(ModelNotSpecified):
qs.update_or_create(defaults={'first': 3, 'third': 2}, second=1)
def test_query_aggregate_multiple_params_with_none_only_field_values_aggregation_with_none(self):
items = [
MockModel(foo=None),
MockModel(foo=None),
MockModel(foo=None),
MockModel(foo=None)
]
self.mock_set.add(*items)
expr_sum = MagicMock(function=AGGREGATES_SUM, source_expressions=[MockModel(name='foo')])
expr_max = MagicMock(function=AGGREGATES_MAX, source_expressions=[MockModel(name='foo')])
expr_min = MagicMock(function=AGGREGATES_MIN, source_expressions=[MockModel(name='foo')])
expr_count = MagicMock(function=AGGREGATES_COUNT, source_expressions=[MockModel(name='foo')])
expr_avg = MagicMock(function=AGGREGATES_AVG, source_expressions=[MockModel(name='foo')])
result = self.mock_set.aggregate(expr_sum, expr_max, expr_min, expr_count, expr_avg,
sum=expr_sum, max=expr_max, min=expr_min, count=expr_count, avg=expr_avg)
assert result['foo__sum'] is None
assert result['foo__max'] is None
assert result['foo__min'] is None
assert result['foo__count'] == 0
assert result['foo__avg'] is None
assert result['sum'] is None
assert result['max'] is None
assert result['min'] is None
assert result['count'] == 0
assert result['avg'] is None
def test_category_awarding_subagency_subawards(mock_matviews_qs,
mock_agencies):
mock_subtier = MockModel(subtier_agency_id=1,
name='Department of Sub-pizza',
abbreviation='DOSP')
mock_agency = MockModel(id=2,
subtier_agency=mock_subtier,
toptier_flag=False)
mock_agency_1 = MockModel(id=3,
subtier_agency=mock_subtier,
toptier_flag=True)
mock_model_1 = MockModel(
awarding_agency_id=2,
awarding_subtier_agency_name='Department of Sub-pizza',
awarding_subtier_agency_abbreviation='DOSP',
amount=10)
mock_model_2 = MockModel(
awarding_agency_id=3,
awarding_subtier_agency_name='Department of Sub-pizza',
awarding_subtier_agency_abbreviation='DOSP',
amount=10)
add_to_mock_objects(mock_matviews_qs, [mock_model_1, mock_model_2])
add_to_mock_objects(mock_agencies['agency'], [mock_agency, mock_agency_1])
test_payload = {
'category': 'awarding_subagency',
'subawards': True,
'page': 1,
'limit': 50
}
spending_by_category_logic = BusinessLogic(test_payload).results()
expected_response = {
'category':
'awarding_subagency',
'limit':
50,
'page_metadata': {
'page': 1,
'next': None,
'previous': None,
'hasNext': False,
'hasPrevious': False
},
'results': [{
'amount': 20,
'name': 'Department of Sub-pizza',
'code': 'DOSP',
'id': 2
}]
}
assert expected_response == spending_by_category_logic
def test_query_aggregate_with_none_only_field_values_performs_correct_aggregation(
self):
items = [
MockModel(foo=None),
MockModel(foo=None),
MockModel(foo=None),
MockModel(foo=None)
]
self.mock_set.add(*items)
expr_sum = MagicMock(function=AGGREGATES_SUM,
source_expressions=[MockModel(name='foo')])
expr_max = MagicMock(function=AGGREGATES_MAX,
source_expressions=[MockModel(name='foo')])
expr_min = MagicMock(function=AGGREGATES_MIN,
source_expressions=[MockModel(name='foo')])
expr_count = MagicMock(function=AGGREGATES_COUNT,
source_expressions=[MockModel(name='foo')])
expr_avg = MagicMock(function=AGGREGATES_AVG,
source_expressions=[MockModel(name='foo')])
result_sum = self.mock_set.aggregate(expr_sum)
result_max = self.mock_set.aggregate(expr_max)
result_min = self.mock_set.aggregate(expr_min)
result_count = self.mock_set.aggregate(expr_count)
result_avg = self.mock_set.aggregate(expr_avg)
assert result_sum['foo__sum'] is None
assert result_max['foo__max'] is None
assert result_min['foo__min'] is None
assert result_count['foo__count'] == 0
assert result_avg['foo__avg'] is None
def test_query_distinct_with_fields(self):
item_1 = MockModel(foo=1, bar='c', foo_bar='x', mock_name='item_1')
item_2 = MockModel(foo=2, bar='a', foo_bar='y', mock_name='item_2')
item_3 = MockModel(foo=1, bar='c', foo_bar='z', mock_name='item_3')
self.mock_set.add(item_2, item_3, item_1, item_3)
results = list(
self.mock_set.order_by('foo', 'bar',
'foo_bar').distinct('foo', 'bar'))
assert results == [item_1, item_2], results
def test_query_get_or_create_raises_does_multiple_objects_returned_when_more_than_one_match_with_defaults(
self):
qs = MockSet(model=create_model('first', 'second', 'third'))
item_1 = MockModel(first=1)
item_2 = MockModel(first=1)
item_3 = MockModel(third=3)
qs.add(item_1, item_2, item_3)
qs.add(item_1, item_2, item_3)
with self.assertRaises(MultipleObjectsReturned):
qs.get_or_create(first=1, defaults={'second': 2})
def test_query_filters_items_by_q_object_and(self):
item_1 = MockModel(mock_name='#1', foo=1, bar='a')
item_2 = MockModel(mock_name='#2', foo=1, bar='b')
item_3 = MockModel(mock_name='#3', foo=3, bar='b')
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.filter(Q(foo=1) & Q(bar='b')))
assert item_1 not in results
assert item_2 in results
assert item_3 not in results
def test_model_choice_field_parse(self):
qs = MockSet(MockModel(pk=0),
MockModel(pk=1),
MockModel(pk=2),
model=ModelTest)
field = forms.ModelChoiceField(queryset=qs)
self.assertEqual(format_data(field, 0), 0)
self.assertEqual(format_data(field, 1), 1)
self.assertEqual(format_data(field, 2), 2)
self.assertRaises(ValidationError, lambda: format_data(field, 4))
def test_query_filters_items_by_q_object_or(self):
item_1 = MockModel(mock_name='#1', foo=1)
item_2 = MockModel(mock_name='#2', foo=2)
item_3 = MockModel(mock_name='#3', foo=3)
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.filter(Q(foo=1) | Q(foo=2)))
assert item_1 in results
assert item_2 in results
assert item_3 not in results
def test_query_get_or_create_creates_new_model_when_no_match(self):
item_1 = MockModel(foo=1)
item_2 = MockModel(foo=2)
item_3 = MockModel(foo=3)
qs = MockSet(model=create_model('foo'))
qs.add(item_1, item_2, item_3)
obj, created = qs.get_or_create(foo=4)
assert hasattr(obj, 'foo') and obj.foo == 4
assert created is True
def test_query_filters_items_by_boolean_attributes(self):
item_1 = MockModel(foo=True, bar=True)
item_2 = MockModel(foo=True, bar=False)
item_3 = MockModel(foo=False, bar=False)
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.filter(foo=True, bar=False))
assert item_1 not in results
assert item_2 in results
assert item_3 not in results
def test_query_filters_items_by_attributes(self):
item_1 = MockModel(foo=1, bar='a')
item_2 = MockModel(foo=1, bar='b')
item_3 = MockModel(foo=2, bar='b')
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.filter(foo=1, bar='b'))
assert item_1 not in results
assert item_2 in results
assert item_3 not in results
def test_query_exclude(self):
item_1 = MockModel(foo=1, bar='a')
item_2 = MockModel(foo=1, bar='b')
item_3 = MockModel(foo=2, bar='b')
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.exclude(foo=1, bar='b'))
assert item_1 in results, results
assert item_2 not in results, results
assert item_3 in results, results
def test_query_filters_items_by_q_object_with_negation(self):
item_1 = MockModel(mock_name='#1', foo=1, bar='a')
item_2 = MockModel(mock_name='#2', foo=1, bar='b')
item_3 = MockModel(mock_name='#3', foo=3, bar='b')
self.mock_set.add(item_1, item_2, item_3)
results = list(self.mock_set.filter(~Q(foo=1) | Q(bar='a')))
assert item_1 in results
assert item_2 not in results
assert item_3 in results
def test_category_funding_agency_awards(mock_matviews_qs, mock_agencies):
mock_toptier = MockModel(toptier_agency_id=1,
name='Department of Calzone',
abbreviation='DOC')
mock_agency = MockModel(id=2,
toptier_agency=mock_toptier,
toptier_flag=True)
mock_agency_1 = MockModel(id=3,
toptier_agency=mock_toptier,
toptier_flag=False)
mock_model_1 = MockModel(
funding_agency_id=2,
funding_toptier_agency_name='Department of Calzone',
funding_toptier_agency_abbreviation='DOC',
generated_pragmatic_obligation=50)
mock_model_2 = MockModel(
funding_agency_id=3,
funding_toptier_agency_name='Department of Calzone',
funding_toptier_agency_abbreviation='DOC',
generated_pragmatic_obligation=50)
add_to_mock_objects(mock_matviews_qs, [mock_model_1, mock_model_2])
add_to_mock_objects(mock_agencies['agency'], [mock_agency, mock_agency_1])
test_payload = {
'category': 'funding_agency',
'subawards': False,
'page': 1,
'limit': 50
}
spending_by_category_logic = BusinessLogic(test_payload).results()
expected_response = {
'category':
'funding_agency',
'limit':
50,
'page_metadata': {
'page': 1,
'next': None,
'previous': None,
'hasNext': False,
'hasPrevious': False
},
'results': [{
'amount': 100,
'name': 'Department of Calzone',
'code': 'DOC',
'id': 2
}]
}
assert expected_response == spending_by_category_logic
def test_category_federal_accounts(mock_matviews_qs):
mock_model_1 = MockModel(
federal_account_id=10,
federal_account_display="020-0001",
account_title="Test Federal Account",
recipient_hash="00000-00000-00000-00000-00000",
parent_recipient_unique_id="000000",
generated_pragmatic_obligation=1,
)
mock_model_2 = MockModel(
federal_account_id=10,
federal_account_display="020-0001",
account_title="Test Federal Account",
recipient_hash="00000-00000-00000-00000-00000",
parent_recipient_unique_id="000000",
generated_pragmatic_obligation=2,
)
add_to_mock_objects(mock_matviews_qs, [mock_model_1, mock_model_2])
test_payload = {
"category": "federal_account",
"filters": {
"recipient_id": "00000-00000-00000-00000-00000-C"
},
"subawards": False,
"page": 1,
"limit": 50,
}
spending_by_category_logic = BusinessLogic(test_payload).results()
expected_response = {
"category":
"federal_account",
"limit":
50,
"page_metadata": {
"page": 1,
"next": None,
"previous": None,
"hasNext": False,
"hasPrevious": False
},
"results": [{
"amount": 3,
"code": "020-0001",
"name": "Test Federal Account",
"id": 10
}],
}
assert expected_response == spending_by_category_logic
def test_query_latest_raises_error_when_both_fields_args_and_field_name_kwarg_supplied(
self):
item_1 = MockModel(foo=1, bar='a')
item_2 = MockModel(foo=2, bar='b')
item_3 = MockModel(foo=3, bar='c')
self.mock_set.add(item_3, item_1, item_2)
self.assertRaises(ValueError,
self.mock_set.latest,
'foo',
field_name='bar')
def test_named_query_values_list(self):
item_1 = MockModel(foo=1, bar=3)
item_2 = MockModel(foo=2, bar=4)
qs = MockSet(item_1, item_2)
results_with_named_fields_fields = qs.values_list('foo',
'bar',
named=True)
assert results_with_named_fields_fields[0].foo == 1
assert results_with_named_fields_fields[0].bar == 3
assert results_with_named_fields_fields[1].foo == 2
assert results_with_named_fields_fields[1].bar == 4
def test_category_naics_awards(mock_matviews_qs):
mock_model_1 = MockModel(naics_code='NAICS 1234',
naics_description='NAICS DESC 1234',
generated_pragmatic_obligation=1)
mock_model_2 = MockModel(naics_code='NAICS 1234',
naics_description='NAICS DESC 1234',
generated_pragmatic_obligation=1)
mock_model_3 = MockModel(naics_code='NAICS 9876',
naics_description='NAICS DESC 9876',
generated_pragmatic_obligation=2)
mock_model_4 = MockModel(naics_code='NAICS 9876',
naics_description='NAICS DESC 9876',
generated_pragmatic_obligation=2)
add_to_mock_objects(
mock_matviews_qs,
[mock_model_1, mock_model_2, mock_model_3, mock_model_4])
test_payload = {
'category': 'naics',
'subawards': False,
'page': 1,
'limit': 50
}
spending_by_category_logic = BusinessLogic(test_payload).results()
expected_response = {
'category':
'naics',
'limit':
50,
'page_metadata': {
'page': 1,
'next': None,
'previous': None,
'hasNext': False,
'hasPrevious': False
},
'results': [{
'amount': 4,
'code': 'NAICS 9876',
'name': 'NAICS DESC 9876',
'id': None
}, {
'amount': 2,
'code': 'NAICS 1234',
'name': 'NAICS DESC 1234',
'id': None
}]
}
assert expected_response == spending_by_category_logic
def test_login_invalid_user(self):
data = {'username': '******', 'password': '******'}
users = MockSet(
MockModel(username='******', password='******'),
MockModel(username='******', password='******'))
LoginSerializer._get_queryset = MagicMock(return_value=users)
serializer = LoginSerializer(data=data)
with self.assertRaises(ValidationError):
serializer.is_valid(raise_exception=True)
def test_query_update_or_create_gets_existing_unique_match_with_defaults(self):
qs = MockSet(
model=create_model('first', 'second', 'third')
)
item_1 = MockModel(first=1)
item_2 = MockModel(second=2)
item_3 = MockModel(third=3)
qs.add(item_1, item_2, item_3)
obj, created = qs.update_or_create(defaults={'first': 3, 'third': 1}, second=2)
assert hasattr(obj, 'second') and obj.second == 2
assert created is False
def test_query_update_does_not_allow_related_model_fields(self):
objects = [
MockModel(foo=MockModel(bar=1)),
MockModel(foo=MockModel(bar=2))
]
qs = MockSet(*objects, model=create_model('foo'))
target = dict(foo__bar=2)
with self.assertRaises(FieldError) as cm:
qs.update(**target)
assert 'Cannot update model field \'{}\''.format(next(
iter(target))) in str(cm.exception)
def test_query_aggregate_performs_min_on_queryset_field(self):
items = [
MockModel(foo=5),
MockModel(foo=10),
MockModel(foo=15),
MockModel(foo=None)
]
self.mock_set.add(*items)
expr = MagicMock(function=AGGREGATES_MIN, source_expressions=[MockModel(name='foo')])
result = self.mock_set.aggregate(expr)
assert result['foo__min'] == min([x.foo for x in items if x.foo is not None])
def test_category_federal_accounts_subawards(
mock_matviews_qs, mock_federal_account, mock_tas, mock_award, mock_financial_account, mock_transaction
):
fa = MockModel(id=10, agency_identifier="020", main_account_code="0001", account_title="Test Federal Account")
add_to_mock_objects(mock_federal_account, [fa])
tas = MockModel(treasury_account_identifier=2, federal_account_id=10)
add_to_mock_objects(mock_tas, [tas])
award = MockModel(id=3)
add_to_mock_objects(mock_award, [award])
fs = MockModel(financial_accounts_by_awards_id=4, submission_id=3, treasury_account=tas, award=award)
add_to_mock_objects(mock_financial_account, [fs])
award.financial_set = MockSet(fs)
t1 = MockModel(award=award, id=5)
t2 = MockModel(award=award, id=6)
add_to_mock_objects(mock_transaction, [t1, t2])
mock_model_1 = MockModel(
transaction=t1, recipient_hash="00000-00000-00000-00000-00000", parent_recipient_unique_id="000000", amount=1
)
mock_model_2 = MockModel(
transaction=t2, recipient_hash="00000-00000-00000-00000-00000", parent_recipient_unique_id="000000", amount=1
)
add_to_mock_objects(mock_matviews_qs, [mock_model_1, mock_model_2])
test_payload = {
"category": "federal_account",
"filters": {"recipient_id": "00000-00000-00000-00000-00000-C"},
"subawards": True,
"page": 1,
"limit": 50,
}
spending_by_category_logic = BusinessLogic(test_payload).results()
expected_response = {
"category": "federal_account",
"limit": 50,
"page_metadata": {"page": 1, "next": None, "previous": None, "hasNext": False, "hasPrevious": False},
"results": [{"amount": 2, "code": "020-0001", "name": "Test Federal Account", "id": 10}],
}
assert expected_response == spending_by_category_logic
