def test_with_good_arguments(self, mocked_use_case):
book = Book.from_dict({
'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'title': '1984',
'author': 'George Orwell',
'year': 1984,
'language': 'English',
'is_available': True,
'reader': None
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(book)
response = self.c.post(reverse('books_list'), {
'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'title': '1984',
'author': 'George Orwell',
'year': 1984,
'language': 'English',
'is_available': True,
'reader': None
})
self.assertEqual(response.status_code, 201)
self.assertEqual(json.loads(json.dumps(book, cls=books.BookEncoder)),
json.loads(response.content.decode('utf-8')))
def process_request(self, request_object):
resp = self.repo.update(pk=request_object.pk,
patch=request_object.patch)
if isinstance(resp, errors.Error):
return response_object.ResponseFailure.from_error(resp)
else:
return response_object.ResponseSuccess(resp)
def test_get(mock_use_case, client):
mock_use_case().execute.return_value = res.ResponseSuccess(books)
http_response = client.get('/books')
assert json.loads(http_response.data) == [dictionary]
assert http_response.status_code == 200
assert http_response.mimetype == 'application/json'
def test_repository_list_without_parameters(self, mocked_use_case):
reader = Reader.from_dict({
'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'full_name': 'VS',
'reg_date': datetime.date(2010, 1, 1)
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(reader)
response = self.c.get(reverse('readers_list'))
self.assertEqual(response.status_code, 200)
self.assertEqual(
json.loads(json.dumps(reader, cls=readers.ReaderEncoder)),
json.loads(response.content.decode('utf-8')))
def test_with_good_arguments(self, mocked_use_case):
reader = Reader.from_dict({
'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'full_name': 'VS',
'reg_date': '2000-10-01'
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(reader)
response = self.c.post(reverse('readers_list'), {})
self.assertEqual(response.status_code, 201)
self.assertEqual(
json.loads(json.dumps(reader, cls=readers.ReaderEncoder)),
json.loads(response.content.decode('utf-8')))
def test_request_object_initialisation_and_use_with_filters(self, mocked_use_case):
mocked_use_case().execute.return_value = ro.ResponseSuccess()
internal_request_object = mock.Mock()
request_object_class = 'Django.books.views.BookListRequestObject'
with mock.patch(request_object_class) as mock_request_object:
mock_request_object.from_dict.return_value = internal_request_object
self.c.get('/books?filter_param1=value1&filter_param2=value2')
mock_request_object.from_dict.assert_called_with(
{'filters': {'param1': 'value1', 'param2': 'value2'}}
)
mocked_use_case().execute.assert_called_with(internal_request_object)
def test_repository_update(self, mocked_use_case):
updated_reader = Reader.from_dict({
'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'full_name': 'John Doe',
'reg_date': '2015-01-01'
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(
updated_reader)
response = self.c.patch('/readers/1/', {"full_name": "John Doe"})
self.assertEqual(response.status_code, 200)
self.assertEqual(
json.loads(json.dumps(updated_reader, cls=readers.ReaderEncoder)),
json.loads(response.content.decode('utf-8')))
def test_repository_return(self, mocked_use_case):
updated_book = Book.from_dict({'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'title': 'Fahrenheit 451',
'author': 'Ray Bradbury',
'year': 1984,
'language': 'English',
'is_available': True,
'reader': None
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(updated_book)
response = self.c.patch('/books/1/', {"reader": None, 'action': 'take'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(json.dumps(updated_book, cls=books.BookEncoder)),
json.loads(response.content.decode('utf-8')))
def test_repository_give(self, mocked_use_case):
reader = Reader.from_dict({
'code': 'r2rwr3re-bdfc-e2ww-5644-hd94id04kd9r',
'full_name': 'John Smith',
'reg_date': datetime.date(2017, 2, 13)
})
updated_book = Book.from_dict({'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
'title': 'Fahrenheit 451',
'author': 'Ray Bradbury',
'year': 1984,
'language': 'English',
'is_available': False,
'reader': reader
})
mocked_use_case().execute.return_value = ro.ResponseSuccess(updated_book)
response = self.c.patch('/books/1/', {"reader": reader, 'action': 'give'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(json.dumps(updated_book, cls=books.BookEncoder)),
json.loads(response.content.decode('utf-8')))
def test_repository_details(self, mocked_use_case):
mocked_use_case().execute.return_value = ro.ResponseSuccess()
response = self.c.delete('/readers/1/')
self.assertEqual(response.status_code, 204)
self.assertEqual('', response.content.decode('utf-8'))
def test_response_success_contains_value(response_value):
response = response_object.ResponseSuccess(response_value)
assert response.value == response_value
def test_response_success_is_true(response_value):
assert bool(response_object.ResponseSuccess(response_value)) is True
def process_request(
self, request_object: GetEventRequestObject) -> ResponseSuccess:
event = self.repo.get_all_events(filter_params=request_object.data)
return res.ResponseSuccess(event)
def process_request(
self, request_object: GetEventForSpecificItemRequestObject
) -> ResponseSuccess:
event = self.repo.get_event_by_item(item_id=request_object.data)
return res.ResponseSuccess(event)
def process_request(self, request_object: None) -> ResponseSuccess:
event = self.repo.newest_event()
return res.ResponseSuccess(event)
def process_request(self, request_object: None) -> ResponseSuccess:
event_count = self.repo.get_event_count_by_type()
return res.ResponseSuccess(event_count)
def process_request(
self, request_object: GetEventRequestObject) -> ResponseSuccess:
event = self.repo.get_event(event_id=request_object.data)
return res.ResponseSuccess(event)
def process_request(self, request_object):
reader = self.repo.from_dict(request_object.init_values)
return response_object.ResponseSuccess(reader)
def process_request(self, request_object):
domain_reader = self.repo.list(filters=request_object.filters)
return response_object.ResponseSuccess(domain_reader)
def process_request(
self, request_object: SaveEventRequestObject) -> ResponseSuccess:
event = self.repo.save(event_data=request_object.data)
return res.ResponseSuccess(event)
