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)