def it_can_construct_a_special_uri_for_fetch_operations(self):
class Doc(Document):
id = fields.NumberField()
class Meta:
backend_type = 'http'
def get_uri(self):
return 'get'
manager = BackendManager('http')
doc = Doc({'id': 1})
expected = {
'id': 1,
'name': 'other',
}
response = Mock(name='mock_http_response')
response.content = json.dumps(expected)
response.status_code = 200
# set the return value of the GET request
self.mock_request.get.return_value = response
# now make the fetch operation
manager.fetch(doc)
# we should have made one GET and one PUT request
eq_([('get', {'url': 'get'})],
self.mock_request.method_calls)
def it_can_fetch_save_and_delete_to_the_specific_backend_manager(self):
with patch("docar.backends.DjangoBackendManager") as mock:
mock_manager = Mock()
mock_manager = mock.return_value
manager = BackendManager("django")
# first assert that the manager is really mocked
ok_(isinstance(manager, Mock))
manager.fetch()
manager.save()
manager.delete()
eq_(True, mock_manager.fetch.called)
eq_(True, mock_manager.save.called)
eq_(True, mock_manager.delete.called)
def it_can_fetch_data_from_the_underlying_model(self):
DjangoModel = Mock(name="DjangoModel")
mock_model = Mock()
mock_model.id = 1
DjangoModel.objects.get.return_value = mock_model
manager = BackendManager('django')
# The manager needs to know which model it connects to
# This is normally done when the Document is created.
manager._model = DjangoModel
doc = Mock(name="mock_document", spec=Document)
field = fields.NumberField()
field.name = "id"
doc.id = 1
doc._context = {}
doc._get_context.return_value = {}
doc._meta.identifier = ["id"]
doc._identifier_state.return_value = {"id": 1}
doc._save.return_value = {"id": 1}
doc._meta.local_fields = [field]
# make sure we are working with correct expectations
eq_(DjangoBackendManager, type(manager))
eq_({'id': 1}, manager.fetch(doc))
eq_([('objects.get', {'id': 1})], DjangoModel.method_calls)
def it_can_fetch_resources_from_a_remote_endpoint(self):
mock_resp = Mock(name="mock_response")
expected = {'id': 1}
mock_resp.content = json.dumps(expected)
mock_resp.status_code = 200
self.mock_request.get.return_value = mock_resp
manager = BackendManager('http')
class Doc(Document):
id = fields.NumberField()
class Meta:
backend_type = 'http'
def uri(self):
return 'http://location'
doc = Doc({'id': 1})
# the http manager returns the response as python dict
content = manager.fetch(doc)
# make sure we are working with correct expectations
eq_(HttpBackendManager, type(manager))
eq_(mock_resp, manager.response)
ok_(isinstance(content, dict))
eq_([('get', {'url': doc.uri()})],
self.mock_request.method_calls)
def it_can_return_a_django_m2m_relationship_as_collection(self):
DjangoModel = Mock(name="DjangoModel")
mock_model = Mock()
mock_model.id = 1
mock_model.get_absolute_url.return_value = "A"
OtherModel = Mock(name="OtherMock")
mock1 = Mock()
mock1.id = 1
mock1.get_absolute_url.return_value = "1"
mock2 = Mock()
mock2.id = 2
mock2.get_absolute_url.return_value = "2"
# This mocks a many2many relation ship, its not a queryset, just a list
mock_model.others.all.return_value = [mock1, mock2]
x = [mock2, mock1]
def mock_side_effect(*args, **kwargs):
return x.pop()
OtherModel.objects.get.side_effect = mock_side_effect
DjangoModel.objects.get.return_value = mock_model
# Now create a simple document setup
class OtherDoc(Document):
id = fields.NumberField()
class Meta:
backend_type = "django"
identifier = "id"
model = OtherModel
class OtherCollection(Collection):
document = OtherDoc
class Doc(Document):
id = fields.NumberField()
others = fields.CollectionField(OtherCollection)
class Meta:
backend_type = "django"
identifier = "id"
model = DjangoModel
manager = BackendManager("django")
# The manager needs to know which model it connects to
# This is normally done when the Document is created.
manager._model = DjangoModel
# make sure we are working with correct expectations
eq_(DjangoBackendManager, type(manager))
doc = Doc({"id": 1})
# doc.fetch()
expected = {"id": 1, "others": [{"id": 1}, {"id": 2}]}
eq_(expected, manager.fetch(doc))
def it_can_take_credentials_as_arguments(self, mock_auth):
auth_token = HTTPBasicAuth('crito', 'secret')
mock_auth.return_value = auth_token
mock_resp = Mock(name="mock_response")
expected = {'id': 1}
mock_resp.status_code = 200
mock_resp.content = json.dumps(expected)
self.mock_request.get.return_value = mock_resp
self.mock_request.delete.return_value = mock_resp
self.mock_request.put.return_value = mock_resp
manager = BackendManager('http')
class Doc(Document):
id = fields.NumberField()
class Meta:
backend_type = 'http'
def uri(self):
return 'http://location'
doc = Doc({'id': 1})
# the http manager returns the response as python dict
content = manager.fetch(doc, username='******', password='******')
manager.delete(doc, username='******', password='******')
manager.save(doc, username='******', password='******')
# make sure we are working with correct expectations
eq_(HttpBackendManager, type(manager))
eq_(mock_resp, manager.response)
ok_(isinstance(content, dict))
eq_([
('get', {'url': doc.uri(), 'auth': auth_token}),
('delete', {'url': doc.uri(), 'auth': auth_token}),
('put', {'url': doc.uri(), 'data': '{"id": 1}',
'auth': auth_token})],
self.mock_request.method_calls)