def test_query_values(self):
item_1 = MockModel(foo=1, bar=3, foobar=5)
item_2 = MockModel(foo=2, bar=4, foobar=6)
qs = MockSet(item_1, item_2)
results_all = qs.values()
results_with_fields = qs.values('foo', 'bar')
assert results_all[0]['foo'] == 1
assert results_all[0]['bar'] == 3
assert results_all[0]['foobar'] == 5
assert results_all[1]['foo'] == 2
assert results_all[1]['bar'] == 4
assert results_all[1]['foobar'] == 6
assert results_with_fields[0]['foo'] == 1
assert results_with_fields[0]['bar'] == 3
assert results_with_fields[1]['foo'] == 2
assert results_with_fields[1]['bar'] == 4
def test_query_datetimes_day(self):
qs = MockSet(model=create_model('date_begin'))
item1 = MockModel(date_begin=datetime.datetime(2017, 1, 2, 1, 2, 3))
item2 = MockModel(date_begin=datetime.datetime(2017, 2, 14, 4, 5, 6))
item3 = MockModel(date_begin=datetime.datetime(2017, 2, 14, 7, 8, 9))
qs.add(item1, item2, item3)
result = qs.datetimes('date_begin', 'day', 'ASC')
assert len(result) == 2
assert result[0] == datetime.datetime(2017, 1, 2, 0, 0, 0)
assert result[1] == datetime.datetime(2017, 2, 14, 0, 0, 0)
result = qs.datetimes('date_begin', 'day', 'DESC')
assert len(result) == 2
assert result[0] == datetime.datetime(2017, 2, 14, 0, 0, 0)
assert result[1] == datetime.datetime(2017, 1, 2, 0, 0, 0)
def test_and_merge_queryset(self):
qs = MockSet(
MockModel(mock_name='model-1', foo='A', bar='1'),
MockModel(mock_name='model-2', foo='B', bar='1'),
MockModel(mock_name='model-3', foo='C', bar='3'),
)
test_qs = qs.all().filter(Q(foo='A'))
test_qs &= test_qs.all().filter(Q(bar='1'))
expected_results = ['model-1']
results = [str(x) for x in test_qs]
# Note: the results may come in various orders, and since we're just focused on the content, we can sort
assert sorted(results) == sorted(expected_results)
test_qs = qs.all().filter(Q(foo='A'))
test_qs &= test_qs.all()
expected_results = ['model-1']
results = [str(x) for x in test_qs]
# Note: the results may come in various orders, and since we're just focused on the content, we can sort
assert sorted(results) == sorted(expected_results)
def test_query_datetimes_second(self):
qs = MockSet(model=create_model('date_begin'))
item1 = MockModel(date_begin=datetime.datetime(2017, 1, 10, 1, 2, 3))
item2 = MockModel(date_begin=datetime.datetime(2017, 1, 10, 1, 2, 3))
item3 = MockModel(date_begin=datetime.datetime(2017, 1, 10, 1, 2, 9))
qs.add(item1, item2, item3)
result = qs.datetimes('date_begin', 'second', 'ASC')
assert len(result) == 2
assert result[0] == datetime.datetime(2017, 1, 10, 1, 2, 3)
assert result[1] == datetime.datetime(2017, 1, 10, 1, 2, 9)
result = qs.datetimes('date_begin', 'second', 'DESC')
assert len(result) == 2
assert result[0] == datetime.datetime(2017, 1, 10, 1, 2, 9)
assert result[1] == datetime.datetime(2017, 1, 10, 1, 2, 3)
def test_query_dates_year(self):
qs = MockSet(model=create_model('date_begin'))
item1 = MockModel(date_begin=datetime.date(2017, 1, 2))
item2 = MockModel(date_begin=datetime.date(2017, 3, 12))
item3 = MockModel(date_begin=datetime.date(2016, 3, 4))
qs.add(item1, item2, item3)
result = qs.dates('date_begin', 'year', 'ASC')
assert len(result) == 2
assert result[0] == datetime.date(2016, 1, 1)
assert result[1] == datetime.date(2017, 1, 1)
result = qs.dates('date_begin', 'year', 'DESC')
assert len(result) == 2
assert result[0] == datetime.date(2017, 1, 1)
assert result[1] == datetime.date(2016, 1, 1)
def mock_matviews_qs(monkeypatch):
"""Mocks all matvies to a single mock queryset"""
mock_qs = MockSet() # mock queryset
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SubawardView.objects', mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryAwardView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryCfdaNumbersView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryNaicsCodesView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryPscCodesView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryStateView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryTransactionGeoView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryTransactionMonthView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryTransactionView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.SummaryView.objects', mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.UniversalAwardView.objects',
mock_qs)
monkeypatch.setattr(
'usaspending_api.awards.models_matviews.UniversalTransactionView.objects',
mock_qs)
yield mock_qs
mock_qs.delete()
def test_trimp_activities(mocker):
user_a = UserFactory.build()
user_b = UserFactory.build()
all_activities = MockSet()
mocker.patch.object(models.Activity, 'objects', all_activities)
all_activities.add(
MockModel(owner=user_b,
trimp=100,
time=datetime.datetime(2017, 5, 4, 3, 2, 1)),
MockModel(owner=user_a,
trimp=100,
time=datetime.datetime(2017, 5, 5, 4, 2, 1)),
MockModel(owner=user_a,
trimp=None,
time=datetime.datetime(2017, 5, 6, 5, 2, 1)),
MockModel(owner=user_a,
trimp=100,
time=datetime.datetime(2017, 5, 7, 6, 2, 1)),
MockModel(owner=user_a,
trimp=100,
time=datetime.datetime(2017, 5, 8, 6, 2, 1)),
MockModel(owner=user_a,
trimp=100,
time=datetime.datetime(2017, 5, 9, 7, 2, 1)),
MockModel(owner=user_b,
trimp=100,
time=datetime.datetime(2017, 5, 10, 8, 2, 1)),
)
activities, start, end = models.Activity.trimp_activities(user_a)
assert set(a.time.day for a in activities) == {5, 7, 8, 9}
assert start.day == 5
assert end.day == 9
activities, start, end = models.Activity.trimp_activities(
user_a,
start=datetime.datetime(2017, 5, 5, 10, 5, 5),
end=datetime.datetime(2017, 5, 8, 10, 5, 5))
assert set(a.time.day for a in activities) == {7, 8}
assert start.day == 5
assert end.day == 8
def test_get_proveedor_by_created(self, mocker):
expected_results = [
Proveedor(id_proveedor='1',
nombre_proveedor='Jhon',
cantidad_articulos=1000,
precio_producto=2000)
]
date = strftime('%Y-%m-%d')
# django-mock-queries nos permite crear Mock QuerySets
# para omitir el acceso a BD
qs = MockSet(expected_results[0])
# Patch el metodo qet_queryset para modificar su comportamiento
# y que nos retorne nuestro queryset y asi omitir el acceso
# a BD
mocker.patch.object(Proveedor.objects, 'get_queryset', return_value=qs)
result = list(Proveedor.objects.get_proveedor_by_created(date))
assert result == expected_results
assert str(result[0]) == expected_results[0].nombre_proveedor
def test_update_active(self):
uuid = uuid4()
instance = UserAccount(
uuid=uuid,
username='******',
password=
'******',
is_active=True)
mockset = MockSet(instance, **{'model': UserAccount})
class FakeModel:
objects = mockset
repository = DjangoCredentialRepository(FakeModel())
credential = repository.find(uuid)
credential.deactivate()
result = repository.update(credential)
assert instance.is_active is False
def test_get_cars_by_created(self, mocker):
expected_results = [
Car(name='Ferrari',
code='fr1',
year=2019,
created=datetime.datetime.now(),
modified=datetime.datetime.now())
]
date = strftime('%Y-%m-%d')
# django-mock-queries nos permite crear Mock QuerySets
# para omitir el acceso a BD
qs = MockSet(expected_results[0])
# Patch el metodo qet_queryset para modificar su comportamiento
# y que nos retorne nuestro queryset y asi omitir el acceso
# a BD
mocker.patch.object(Car.objects, 'get_queryset', return_value=qs)
result = list(Car.objects.get_cars_by_created(date))
assert result == expected_results
assert str(result[0]) == expected_results[0].code
def test_list(self, rf, mocker): # pylint: disable=no-self-use disable=invalid-name
"""
test list
"""
# django-pytest nos permite pasar por inyeccion de dependencia
# a nuestros tests algunos objetos, en este caso le "INYECTE"
# el objeto rf que no es mas que el comun RequestFactory
# y mocker que nos permite hacer patch a objetos y funciones
url = reverse('genre-list')
request = rf.get(url)
# usamos la libreria django-mock-queries para crear un Mock
# de nuestro queryset y omitir el acceso a BD
queryset = MockSet(Genre(name='Drama'), Genre(name='Comedy'))
mocker.patch.object(GenreViewSet,
'get_queryset',
return_value=queryset)
response = GenreViewSet.as_view({'get': 'list'})(request).render()
assert response.status_code == 200
assert len(json.loads(response.content)) == 2
def test_get_aggregate_and_proceed_count(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_query_period_uom(WEEKS)
c.set_query_period_quantity(10)
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=COUNT)
message.chat = chat
update.message = message
fake_data = MockSet()
for _i in range(1, 15):
fake_data.add(
MockModel(
mock_name=f'name{_i}',
id=f'id{_i}',
name=f'name{_i}',
status='pending',
created_at=timezone.now(),
))
mocker.patch(
INITIAL_QUERY_SET_METHOD,
return_value=fake_data,
)
data = c.get_aggregate_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == ConversationHandler.END
assert c.aggregate_type == COUNT
def test_count_suspicions_with_mockset(
self,
mocker,
reimbursement_data,
):
data = reimbursement_data.copy()
data['document_id'] = 42 * 2
del data['suspicions']
del data['probability']
mock_queryset = MockSet(
Reimbursement(**reimbursement_data),
Reimbursement(**data),
model=Reimbursement,
)
mocker.patch(
'jarbas.chamber_of_deputies.models.Reimbursement'
'.objects',
mock_queryset,
)
queryset = Reimbursement.objects.filter(suspicions__isnull=True)
assert queryset.count() == 1
def test_extract_success(self):
qs = MockSet()
class TestExpression():
def __init__(self, template):
self.template = template
template = '%(function)s(MONTH from (%(expressions)s) + INTERVAL \'3 months\')'
value = datetime.datetime(2007, 10, 1)
expected_result = 1
result = qs.extract(TestExpression(template), [value])
assert expected_result == result
template = "%(function)s(QUARTER from (%(expressions)s) + INTERVAL '3 months')"
value = datetime.datetime(2008, 1, 1)
expected_result = 2
result = qs.extract(TestExpression(template), [value])
assert expected_result == result
template = "%(function)s(YEAR from (%(expressions)s) + INTERVAL '3 months')"
value = datetime.datetime(2007, 10, 1)
expected_result = 2008
result = qs.extract(TestExpression(template), [value])
assert expected_result == result
def mock_set(mocker):
mockset = MockSet(
UserAccount(uuid=UUID_MOCK, username='******',
password='******'),
UserAccount(uuid=uuid4(), username='******', password='******'))
mocker.patch.object(UserAccount, 'objects', mockset)
class DoesTokenExistTestCase(TestCase):
# Sets up some fake bookings
fake_bookings = MockSet(
MockModel(setid='LIVE-17-18',
finishtime='16:00',
id=8869,
weeknumber=12.0,
starttime='13:00',
bookabletype='CB',
title='Some topic',
finishdatetime=datetime.datetime(2017, 11, 14, 16, 0),
descrip='8 x rooms needed',
slotid=1662773,
sitename='IOE - Bedford Way, 20',
phone=None,
siteid='162',
roomname='IOE - Bedford Way (20) - 790',
condisplayname='Some Lecturer',
startdatetime=datetime.datetime(2017, 11, 14, 13, 0),
roomid='790',
bookingid=None),
MockModel(setid='LIVE-17-18',
finishtime='12:30',
id=13692,
weeknumber=21.0,
starttime='11:00',
bookabletype='CB',
title='Another topic',
finishdatetime=datetime.datetime(2018, 1, 19, 12, 30),
descrip=None,
slotid=1673854,
sitename='IOE - Bedford Way, 20',
phone=None,
siteid='162',
roomname='Some other room',
condisplayname='Some other lecturer',
startdatetime=datetime.datetime(2018, 1, 19, 11, 0),
roomid='418',
bookingid=None))
booking_objects = unittest.mock.patch(
'roombookings.models.Booking.objects', fake_bookings)
bookinga_objects = unittest.mock.patch(
'roombookings.models.BookingA.objects', fake_bookings)
bookingb_objects = unittest.mock.patch(
'roombookings.models.BookingB.objects', fake_bookings)
fake_locks = MockSet(MockModel(a=True, b=False))
lock_objects = unittest.mock.patch('timetable.models.Lock.objects',
fake_locks)
def setUp(self):
self.factory = APIRequestFactory()
# General temporary token for tests
self.token = get_temp_token()
# A valid token to use later
self.valid_token = get_temp_token()
# Standard Token data
self.user_ = User.objects.create(cn="test", employee_id=7357)
self.app = App.objects.create(user=self.user_, name="An App")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_no_token_provided(self):
request = self.factory.get('/a/random/path')
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 400)
self.assertFalse(content["ok"])
self.assertEqual(content["error"], "No token provided.")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_invalid_token_provided(self):
request = self.factory.get('/a/random/path', {'token': 'uclapi'})
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 400)
self.assertFalse(content["ok"])
self.assertEqual(content["error"], "Token is invalid.")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_invalid_temp_token_provided(self):
request = self.factory.get('/a/random/path',
{'token': 'uclapi-temp-invalid-token'})
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 400)
self.assertFalse(content["ok"])
self.assertEqual(content["error"],
"Temporary token is either invalid or expired.")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_temp_token_wrong_path(self):
request = self.factory.get('/a/path', {'token': self.token})
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 400)
self.assertFalse(content["ok"])
self.assertEqual(content["error"],
"Temporary token can only be used for /bookings.")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_temp_token_page_token_provided(self):
request = self.factory.get('/roombookings/bookings', {
'token': self.token,
'page_token': 'next_page_comes_here'
})
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 400)
self.assertFalse(content["ok"])
self.assertEqual(content["error"],
"Temporary token can only return one booking.")
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_temp_token_overused(self):
request = self.factory.get('/roombookings/bookings',
{'token': self.token})
for _ in repeat(None, 11):
response = get_bookings(request)
content = json.loads(response.content.decode())
self.assertEqual(response.status_code, 429)
self.assertFalse(content["ok"])
self.assertEqual("You have been throttled. Please try again in ",
content["error"][:45])
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_temp_token_valid(self):
request = self.factory.get('/roombookings/bookings',
{'token': self.valid_token})
response = get_bookings(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(request.GET['results_per_page'], 1)
@booking_objects
@bookinga_objects
@bookingb_objects
@lock_objects
def test_normal_token_valid(self):
request = self.factory.get('/roombookings/bookings',
{'token': self.app.api_token})
response = get_bookings(request)
self.assertEqual(response.status_code, 200)
class TestLoadData:
pytestmark = pytest.mark.django_db
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_bulk_create_lt_10000(self, load_geography, MockDatasetData,
good_input):
dataset = Mock()
dataset.geography_hierarchy.version = 9999
dataloader.loaddata(dataset, good_input, 0)
MockDatasetData.objects.bulk_create.assert_called_once()
load_geography.called_with("YYY", 222)
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_bulk_create_gt_10000(self, load_geography, MockDatasetData,
good_input):
dataset = Mock()
load_geography.return_value = "XXX"
input_data = [dict(good_input[0]) for i in range(20001)]
dataloader.loaddata(dataset, input_data, 0)
assert MockDatasetData.objects.bulk_create.call_count == 3
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_bulk_check_load_geography_call(self, load_geography,
MockDatasetData, good_input):
dataset = Mock()
dataset.geography_hierarchy.version = 9999
load_geography.return_value = "XXX"
dataloader.loaddata(dataset, good_input, 0)
load_geography.assert_called_with("YYY", 9999)
@pytest.mark.django_db
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_missing_geography(self, load_geography, MockDatasetData,
good_input):
dataset = Mock()
load_geography.side_effect = models.Geography.DoesNotExist()
try:
(errors, warnings) = dataloader.loaddata(dataset, good_input, 0)
assert len(warnings) == 2
assert len(errors) == 0
except models.Geography.DoesNotExist:
assert False
assert MockDatasetData.objects.bulk_create.call_count == 1
MockDatasetData.objects.bulk_create.assert_called_with([], 1000)
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_bad_count(self, load_geography):
dataset = Mock()
input_data = [{"geography": "XXX", "count": ""}]
(errors, warnings) = dataloader.loaddata(dataset, input_data, 0)
assert len(warnings) == 0
assert len(errors) == 1
@patch('wazimap_ng.datasets.models.Group.objects')
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
def test_datasetdata_created(self, load_geography, MockDatasetData,
group_objects, good_input_with_groups):
data = good_input_with_groups
dataset = Mock(spec=models.Dataset)
dataloader.loaddata(dataset, data, 0)
assert MockDatasetData.call_count == 2
args1 = MockDatasetData.call_args_list[0][1]
args2 = MockDatasetData.call_args_list[1][1]
assert args1["data"] == data[0]
assert args1["dataset"] == dataset
assert args2["data"] == data[1]
assert args2["dataset"] == dataset
@patch('wazimap_ng.datasets.models.DatasetData')
@patch('wazimap_ng.datasets.dataloader.load_geography')
@patch('wazimap_ng.datasets.dataloader.create_groups')
def test_create_groups_called(self, create_groups, load_geography,
MockDatasetData, good_input_with_groups):
data = good_input_with_groups
dataset = Mock(spec=models.Dataset)
dataloader.loaddata(dataset, data, 0)
assert create_groups.call_count == 1
create_groups.assert_called_with(dataset, ["group1", "group2"])
datasetdata = MockSet()
datasetdata_objects = patch(
'wazimap_ng.datasets.models.DatasetData.objects', datasetdata)
def test_length2(self):
q = MockSet(MockModel(), MockModel())
n = len(q)
self.assertEqual(2, n)
def test_query_values_raises_attribute_error_when_field_is_not_in_meta_concrete_fields(
self):
qs = MockSet(MockModel(foo=1), MockModel(foo=2))
self.assertRaises(FieldError, qs.values, 'bar')
JohnTheOwner = MockModel(id=1, pk=1, name='john')
BillTheStranger = MockModel(id=2, pk=2, name='bill')
BoringBook = MockModel(id='10',
pk='10',
user_id=JohnTheOwner.id,
user=JohnTheOwner,
title='Boring book')
InterestingBook = MockModel(id='11',
pk='11',
user_id=JohnTheOwner.id,
user=JohnTheOwner,
title='Interesting book')
mock_book_queryset = MockSet(BoringBook, InterestingBook, model=BoringBook)
class BaseViewMixin:
renderer_classes = (CamelCaseJSONRenderer, )
parser_classes = (CamelCaseJSONParser, )
queryset = mock_book_queryset
serializer_class = PlainViewSetSerializer
permission_classes = ()
class BaseListCreateAPIView(BaseViewMixin, generics.ListCreateAPIView):
pass
def update_user(mocker):
mockset = MockSet(
UserAccount(uuid=UUID_MOCK, username='******',
password='******'))
mocker.patch.object(UserAccount, 'objects', mockset)
return mocker.patch.object(UserAccount, 'save')
def test_query_create_raises_model_not_specified_when_mockset_model_is_none(
self):
qs = MockSet()
attrs = dict(foo=1, bar='a')
self.assertRaises(ModelNotSpecified, qs.create, **attrs)
def test_query_implements_iterator_on_items(self):
items = [1, 2, 3]
assert [x for x in MockSet(*items)] == items
def test_query_counts_items_in_set(self):
items = [1, 2, 3]
assert MockSet(*items).count() == len(items)
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
def test_query_values_list_raises_type_error_when_kwargs_other_than_flat_specified(
self):
qs = MockSet(MockModel(foo=1), MockModel(foo=2))
self.assertRaises(TypeError, qs.values_list, arg='value')
class FakeModel:
objects = MockSet()
def test_query_values_list_raises_type_error_when_flat_specified_with_multiple_fields(
self):
qs = MockSet(MockModel(foo=1), MockModel(foo=2))
self.assertRaises(TypeError, qs.values_list, 'foo', 'bar', flat=True)
def test_query_create_raises_value_error_when_kwarg_key_is_not_in_concrete_fields(
self):
qs = MockSet(model=create_model('first', 'second', 'third'))
attrs = dict(first=1, second=2, third=3, fourth=4)
with self.assertRaises(ValueError):
qs.create(**attrs)
def test_query_values_list_raises_not_implemented_if_no_fields_specified(
self):
qs = MockSet(MockModel(foo=1), MockModel(foo=2))
self.assertRaises(NotImplementedError, qs.values_list)