def test_valid_resource_paths_unicode(self): """:meth:`resource` should return a :class:`pysnow.Response` object with paths set to the expected value""" api_path = u"/api/path" base_path = u"/base/path" c = Client(user="******", password="******", instance="instance") r = c.resource(api_path=api_path, base_path=base_path) self.assertEquals(r._api_path, api_path) self.assertEquals(r._base_path, base_path)
def test_valid_resource_paths_unicode(self): """:meth:`resource` should return a :class:`pysnow.Response` object with paths set to the expected value""" api_path = u'/api/path' base_path = u'/base/path' c = Client(user="******", password="******", instance="instance") r = c.resource(api_path=api_path, base_path=base_path) self.assertEquals(r._api_path, api_path) self.assertEquals(r._base_path, base_path)
class TestResourceRequest(unittest.TestCase): """Performs resource-request tests""" def setUp(self): self.error_message_body = { 'message': 'test_message', 'detail': 'test_details' } self.record_response_get_dict = { 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo', 'attr2': 'bar' } self.record_response_get_one = [{ 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo', 'attr2': 'bar' }] self.record_response_get_three = [{ 'sys_id': '37ea2a00cf5c9c995399098ace1a5e19', 'attr1': 'foo1', 'attr2': 'bar1' }, { 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo2', 'attr2': 'bar2' }, { 'sys_id': 'a00cf5c9c9953990e1998ace1a537ea2', 'attr1': 'foo3', 'attr2': 'bar3' }] self.record_response_create = { 'sys_id': '90e11a537ea2a00cf598ace9c99539c9', 'attr1': 'foo_create', 'attr2': 'bar_create' } self.record_response_update = { 'sys_id': '2a00cf5c9c99539998ace1a537ea0e19', 'attr1': 'foo_updated', 'attr2': 'bar_updated' } self.record_response_delete = {'status': 'record deleted'} self.client_kwargs = { 'user': '******', 'password': '******', 'instance': 'mock_instance' } self.attachment = { 'sys_id': 'attachment_sys_id', 'size_bytes': '512', 'file_name': 'test1.txt' } self.attachment_path = 'tests/data/attachment.txt' self.base_path = '/api/now' self.api_path = '/table/incident' self.client = Client(**self.client_kwargs) self.resource = self.client.resource(base_path=self.base_path, api_path=self.api_path) self.mock_url_builder = self.resource._url_builder self.attachment_upload_url = self.resource._base_url + self.resource._base_path + '/attachment/file' self.mock_url_builder_base = self.resource._url_builder.get_url() self.mock_url_builder_sys_id = ( self.mock_url_builder.get_appended_custom('/{0}'.format( self.record_response_get_one[0]['sys_id']))) self.dict_query = {'sys_id': self.record_response_get_one[0]['sys_id']} self.get_fields = ['foo', 'bar'] def test_create_resource(self): """:class:`Resource` object repr type should be string, and its path should be set to api_path + base_path """ r = self.client.resource(base_path=self.base_path, api_path=self.api_path) resource_repr = type(repr(r)) self.assertEquals(resource_repr, str) self.assertEquals(r._base_path, self.base_path) self.assertEquals(r._api_path, self.api_path) self.assertEquals(r.path, self.base_path + self.api_path) @httpretty.activate def test_response_count(self): """:prop:`count` of :class:`pysnow.Response` should raise an exception if count is set to non-integer""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(TypeError, setattr, response, 'count', 'foo') self.assertRaises(TypeError, setattr, response, 'count', True) self.assertRaises(TypeError, setattr, response, 'count', {'foo': 'bar'}) @httpretty.activate def test_response_error(self): """:class:`pysnow.Response` should raise an exception if an error is encountered in the response body""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_error( self.error_message_body), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) expected_str = "Error in response. Message: %s, Details: %s" % ( self.error_message_body['message'], self.error_message_body['detail']) try: response.first() except ResponseError as e: self.assertEquals(str(e), expected_str) @httpretty.activate def test_get_request_fields(self): """:meth:`get_request` should return a :class:`pysnow.Response` object""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json") response = self.resource.get(self.dict_query, fields=self.get_fields) qs = qs_as_dict(response._response.request.url) str_fields = ','.join(self.get_fields) # List of fields should end up as comma-separated string self.assertEquals(type(response), Response) self.assertEquals(qs['sysparm_fields'], str_fields) @httpretty.activate def test_get_offset(self): """offset passed to :meth:`get` should set sysparm_offset in query""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") offset = 5 response = self.resource.get(self.dict_query, offset=offset) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs['sysparm_offset']), offset) @httpretty.activate def test_get_limit(self): """limit passed to :meth:`get` should set sysparm_limit in QS""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") limit = 2 response = self.resource.get(self.dict_query, limit=limit) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs['sysparm_limit']), limit) @httpretty.activate def test_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(self.dict_query) result = response.one() self.assertEquals(result['sys_id'], self.record_response_get_one[0]['sys_id']) @httpretty.activate def test_get_all_empty(self): """:meth:`all` generator of :class:`pysnow.Response` should return an empty list if there are no matches""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = list(response.all()) self.assertEquals(result, []) @httpretty.activate def test_get_all_single(self): """Single items with all() using the stream parser should return a list containing the item""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_dict), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = list(response.all())[0] self.assertEquals(result, self.record_response_get_dict) @httpretty.activate def test_get_buffer_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(MissingResult, response.one) @httpretty.activate def test_get_stream_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) self.assertRaises(MissingResult, response.first) @httpretty.activate def test_http_error_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an HTTPError exception if a non-200 response code was encountered""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=500, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(HTTPError, response.one) @httpretty.activate def test_get_one_many(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(MultipleResults, response.one) @httpretty.activate def test_get_one_empty(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if no matches were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(NoResults, response.one) @httpretty.activate def test_get_one_or_none_empty(self): """:meth:`one_or_none` of :class:`pysnow.Response` should return `None` if no matches were found """ httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query) result = response.one_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none_empty(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return None if no records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first(self): """:meth:`first` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first_empty(self): """:meth:`first` of :class:`pysnow.Response` should raise an exception if matches were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) self.assertRaises(NoResults, response.first) @httpretty.activate def test_create(self): """:meth:`create` should return a dictionary of the new record""" httpretty.register_uri(httpretty.POST, self.mock_url_builder_base, body=get_serialized_result( self.record_response_create), status=200, content_type="application/json") response = self.resource.create(self.record_response_create) self.assertEquals(type(response.one()), dict) self.assertEquals(response.one(), self.record_response_create) @httpretty.activate def test_update(self): """:meth:`update` should return a dictionary of the updated record""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result( self.record_response_update), status=200, content_type="application/json") response = self.resource.update(self.dict_query, self.record_response_update) result = response.one() self.assertEquals(type(result), dict) self.assertEquals(self.record_response_update['attr1'], result['attr1']) @httpretty.activate def test_update_invalid_payload(self): """:meth:`update` should raise an exception if payload is of invalid type""" self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, 'foo') self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, False) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, 1) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ('foo', 'bar')) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ['foo', 'bar']) @httpretty.activate def test_delete(self): """:meth:`delete` should return a dictionary containing status""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result( self.record_response_delete), status=204, content_type="application/json") result = self.resource.delete(self.dict_query) self.assertEquals(type(result), dict) self.assertEquals(result['status'], 'record deleted') @httpretty.activate def test_delete_chained(self): """:meth:`Response.delete` should return a dictionary containing status""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result( self.record_response_delete), status=204, content_type="application/json") result = self.resource.get(query={}).delete() self.assertEquals(type(result), dict) self.assertEquals(result['status'], 'record deleted') @httpretty.activate def test_custom(self): """:meth:`custom` should return a :class:`pysnow.Response` object""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") method = 'GET' response = self.resource.request(method) self.assertEquals(response._response.request.method, method) self.assertEquals(type(response), Response) @httpretty.activate def test_custom_with_headers(self): """Headers provided to :meth:`custom` should end up in the request""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") headers = {'foo': 'bar'} response = self.resource.request('GET', headers=headers) self.assertEquals(response._response.request.headers['foo'], headers['foo']) @httpretty.activate def test_custom_with_path(self): """path_append passed to :meth:`custom` should get appended to the request path""" path_append = '/foo' httpretty.register_uri(httpretty.GET, self.mock_url_builder_base + path_append, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") response = self.resource.request('GET', path_append='/foo') self.assertEquals(response._response.status_code, 200) @httpretty.activate def test_custom_with_path_invalid(self): """:meth:`custom` should raise an exception if the provided path is invalid""" self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append='foo') self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append={'foo': 'bar'}) self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append='foo/') self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append=True) @httpretty.activate def test_response_repr(self): """:meth:`get` should result in response obj repr describing the response""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) response_repr = repr(response) self.assertEquals(response_repr, '<Response [200 - GET]>') def test_attachment_non_table(self): """Accessing `Resource.attachments` from a non-table API should fail""" resource = self.client.resource(base_path=self.base_path, api_path='/invalid') self.assertRaises(InvalidUsage, getattr, resource, 'attachments') def test_attachment_type(self): """`Resource.attachments` should be of type Attachment""" attachment_type = type(self.resource.attachments) self.assertEqual(attachment_type, Attachment) def test_get_record_link(self): """`Resource.get_record_link()` should return full URL to the record""" record_link = self.resource.get_record_link( '98ace1a537ea2a00cf5c9c9953990e19') self.assertEqual(record_link, self.mock_url_builder_sys_id) @httpretty.activate def test_get_response_item(self): """Accessing the response as a dict should work""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) self.assertEquals(response['sys_id'], self.record_response_get_one[0].get('sys_id')) @httpretty.activate def test_get_buffered_first(self): """Using Response.first() without stream=True should fail""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) self.assertRaises(InvalidUsage, response.first) @httpretty.activate def test_response_update(self): """Using Response.update should update the queried record""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result( self.record_response_update), status=200, content_type="application/json") response = self.resource.get(query={}).update( self.record_response_update) self.assertEqual(self.record_response_update['sys_id'], response['sys_id']) @httpretty.activate def test_response_upload(self): """Using Response.upload() should attach the file to the queried record and return metadata""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result( self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, self.attachment_upload_url, body=get_serialized_result(self.attachment), status=201, content_type="application/json") response = self.resource.get(query={}).upload( file_path=self.attachment_path) self.assertEqual(self.attachment['file_name'], response['file_name'])
class TestResourceRequest(unittest.TestCase): """Performs resource-request tests""" def setUp(self): self.error_message_body = { 'message': 'test_message', 'detail': 'test_details' } self.record_response_get_dict = { 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo', 'attr2': 'bar' } self.record_response_get_one = [{ 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo', 'attr2': 'bar' }] self.record_response_get_three = [ { 'sys_id': '37ea2a00cf5c9c995399098ace1a5e19', 'attr1': 'foo1', 'attr2': 'bar1' }, { 'sys_id': '98ace1a537ea2a00cf5c9c9953990e19', 'attr1': 'foo2', 'attr2': 'bar2' }, { 'sys_id': 'a00cf5c9c9953990e1998ace1a537ea2', 'attr1': 'foo3', 'attr2': 'bar3' } ] self.record_response_create = { 'sys_id': '90e11a537ea2a00cf598ace9c99539c9', 'attr1': 'foo_create', 'attr2': 'bar_create' } self.record_response_update = { 'sys_id': '2a00cf5c9c99539998ace1a537ea0e19', 'attr1': 'foo_updated', 'attr2': 'bar_updated' } self.record_response_delete = { 'status': 'record deleted' } self.client_kwargs = { 'user': '******', 'password': '******', 'instance': 'mock_instance' } self.attachment = { 'sys_id': 'attachment_sys_id', 'size_bytes': '512', 'file_name': 'test1.txt' } self.attachment_path = 'tests/data/attachment.txt' self.base_path = '/api/now' self.api_path = '/table/incident' self.client = Client(**self.client_kwargs) self.resource = self.client.resource(base_path=self.base_path, api_path=self.api_path) self.mock_url_builder = self.resource._url_builder self.attachment_upload_url = self.resource._base_url + self.resource._base_path + '/attachment/file' self.mock_url_builder_base = self.resource._url_builder.get_url() self.mock_url_builder_sys_id = (self.mock_url_builder .get_appended_custom('/{0}'.format(self.record_response_get_one[0]['sys_id']))) self.dict_query = {'sys_id': self.record_response_get_one[0]['sys_id']} self.get_fields = ['foo', 'bar'] def test_create_resource(self): """:class:`Resource` object repr type should be string, and its path should be set to api_path + base_path """ r = self.client.resource(base_path=self.base_path, api_path=self.api_path) resource_repr = type(repr(r)) self.assertEquals(resource_repr, str) self.assertEquals(r._base_path, self.base_path) self.assertEquals(r._api_path, self.api_path) self.assertEquals(r.path, self.base_path + self.api_path) @httpretty.activate def test_response_headers(self): """Request response headers should be available in Response.headers property""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=200, adding_headers={'x-test-1': 'foo', 'x-test-2': 'bar'}, content_type="application/json") response = self.resource.get(self.dict_query) self.assertEqual(response.headers['x-test-1'], 'foo') self.assertEqual(response.headers['x-test-2'], 'bar') @httpretty.activate def test_response_count(self): """:prop:`count` of :class:`pysnow.Response` should raise an exception if count is set to non-integer""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(TypeError, setattr, response, 'count', 'foo') self.assertRaises(TypeError, setattr, response, 'count', True) self.assertRaises(TypeError, setattr, response, 'count', {'foo': 'bar'}) @httpretty.activate def test_response_error(self): """:class:`pysnow.Response` should raise an exception if an error is encountered in the response body""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_error(self.error_message_body), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) expected_str = "Error in response. Message: %s, Details: %s" % (self.error_message_body['message'], self.error_message_body['detail']) try: response.first() except ResponseError as e: self.assertEquals(str(e), expected_str) @httpretty.activate def test_get_request_fields(self): """:meth:`get_request` should return a :class:`pysnow.Response` object""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json") response = self.resource.get(self.dict_query, fields=self.get_fields) qs = qs_as_dict(response._response.request.url) str_fields = ','.join(self.get_fields) # List of fields should end up as comma-separated string self.assertEquals(type(response), Response) self.assertEquals(qs['sysparm_fields'], str_fields) @httpretty.activate def test_get_offset(self): """offset passed to :meth:`get` should set sysparm_offset in query""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") offset = 5 response = self.resource.get(self.dict_query, offset=offset) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs['sysparm_offset']), offset) @httpretty.activate def test_get_limit(self): """limit passed to :meth:`get` should set sysparm_limit in QS""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") limit = 2 response = self.resource.get(self.dict_query, limit=limit) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs['sysparm_limit']), limit) @httpretty.activate def test_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(self.dict_query) result = response.one() self.assertEquals(result['sys_id'], self.record_response_get_one[0]['sys_id']) @httpretty.activate def test_get_all_empty(self): """:meth:`all` generator of :class:`pysnow.Response` should return an empty list if there are no matches""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = list(response.all()) self.assertEquals(result, []) @httpretty.activate def test_get_all_single(self): """Single items with all() using the stream parser should return a list containing the item""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_dict), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = list(response.all())[0] self.assertEquals(result, self.record_response_get_dict) @httpretty.activate def test_get_buffer_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(MissingResult, response.one) @httpretty.activate def test_get_stream_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) self.assertRaises(MissingResult, response.first) @httpretty.activate def test_http_error_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an HTTPError exception if a non-200 response code was encountered""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, status=500, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(HTTPError, response.one) @httpretty.activate def test_get_one_many(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(MultipleResults, response.one) @httpretty.activate def test_get_one_empty(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if no matches were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query) self.assertRaises(NoResults, response.one) @httpretty.activate def test_get_one_or_none_empty(self): """:meth:`one_or_none` of :class:`pysnow.Response` should return `None` if no matches were found """ httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query) result = response.one_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none_empty(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return None if no records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first(self): """:meth:`first` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) result = response.first() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first_empty(self): """:meth:`first` of :class:`pysnow.Response` should raise an exception if matches were found""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json") response = self.resource.get(self.dict_query, stream=True) self.assertRaises(NoResults, response.first) @httpretty.activate def test_create(self): """:meth:`create` should return a dictionary of the new record""" httpretty.register_uri(httpretty.POST, self.mock_url_builder_base, body=get_serialized_result(self.record_response_create), status=200, content_type="application/json") response = self.resource.create(self.record_response_create) self.assertEquals(type(response.one()), dict) self.assertEquals(response.one(), self.record_response_create) @httpretty.activate def test_update(self): """:meth:`update` should return a dictionary of the updated record""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_update), status=200, content_type="application/json") response = self.resource.update(self.dict_query, self.record_response_update) result = response.one() self.assertEquals(type(result), dict) self.assertEquals(self.record_response_update['attr1'], result['attr1']) @httpretty.activate def test_update_invalid_payload(self): """:meth:`update` should raise an exception if payload is of invalid type""" self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, 'foo') self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, False) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, 1) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ('foo', 'bar')) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ['foo', 'bar']) @httpretty.activate def test_delete(self): """:meth:`delete` should return a dictionary containing status""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_delete), status=204, content_type="application/json") result = self.resource.delete(self.dict_query) self.assertEquals(type(result), dict) self.assertEquals(result['status'], 'record deleted') @httpretty.activate def test_delete_chained(self): """:meth:`Response.delete` should return a dictionary containing status""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_delete), status=204, content_type="application/json") result = self.resource.get(query={}).delete() self.assertEquals(type(result), dict) self.assertEquals(result['status'], 'record deleted') @httpretty.activate def test_custom(self): """:meth:`custom` should return a :class:`pysnow.Response` object""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") method = 'GET' response = self.resource.request(method) self.assertEquals(response._response.request.method, method) self.assertEquals(type(response), Response) @httpretty.activate def test_custom_with_headers(self): """Headers provided to :meth:`custom` should end up in the request""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") headers = {'foo': 'bar'} response = self.resource.request('GET', headers=headers) self.assertEquals(response._response.request.headers['foo'], headers['foo']) @httpretty.activate def test_custom_with_path(self): """path_append passed to :meth:`custom` should get appended to the request path""" path_append = '/foo' httpretty.register_uri(httpretty.GET, self.mock_url_builder_base + path_append, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") response = self.resource.request('GET', path_append='/foo') self.assertEquals(response._response.status_code, 200) @httpretty.activate def test_custom_with_path_invalid(self): """:meth:`custom` should raise an exception if the provided path is invalid""" self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append='foo') self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append={'foo': 'bar'}) self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append='foo/') self.assertRaises(InvalidUsage, self.resource.request, 'GET', path_append=True) @httpretty.activate def test_response_repr(self): """:meth:`get` should result in response obj repr describing the response""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) response_repr = repr(response) self.assertEquals(response_repr, '<Response [200 - GET]>') def test_attachment_non_table(self): """Accessing `Resource.attachments` from a non-table API should fail""" resource = self.client.resource(base_path=self.base_path, api_path='/invalid') self.assertRaises(InvalidUsage, getattr, resource, 'attachments') def test_attachment_type(self): """`Resource.attachments` should be of type Attachment""" attachment_type = type(self.resource.attachments) self.assertEqual(attachment_type, Attachment) def test_get_record_link(self): """`Resource.get_record_link()` should return full URL to the record""" record_link = self.resource.get_record_link('98ace1a537ea2a00cf5c9c9953990e19') self.assertEqual(record_link, self.mock_url_builder_sys_id) @httpretty.activate def test_get_response_item(self): """Accessing the response as a dict should work""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) self.assertEquals(response['sys_id'], self.record_response_get_one[0].get('sys_id')) @httpretty.activate def test_get_buffered_first(self): """Using Response.first() without stream=True should fail""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") response = self.resource.get(query={}) self.assertRaises(InvalidUsage, response.first) @httpretty.activate def test_response_update(self): """Using Response.update should update the queried record""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_update), status=200, content_type="application/json") response = self.resource.get(query={}).update(self.record_response_update) self.assertEqual(self.record_response_update['sys_id'], response['sys_id']) @httpretty.activate def test_response_upload(self): """Using Response.upload() should attach the file to the queried record and return metadata""" httpretty.register_uri(httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, self.attachment_upload_url, body=get_serialized_result(self.attachment), status=201, content_type="application/json") response = self.resource.get(query={}).upload(file_path=self.attachment_path) self.assertEqual(self.attachment['file_name'], response['file_name'])
class TestResourceRequest(unittest.TestCase): """Performs resource-request tests""" def setUp(self): self.error_message_body = { "message": "test_message", "detail": "test_details" } self.record_response_get_dict = { "sys_id": "98ace1a537ea2a00cf5c9c9953990e19", "attr1": "foo", "attr2": "bar", } self.record_response_get_one = [{ "sys_id": "98ace1a537ea2a00cf5c9c9953990e19", "attr1": "foo", "attr2": "bar", }] self.record_response_get_three = [ { "sys_id": "37ea2a00cf5c9c995399098ace1a5e19", "attr1": "foo1", "attr2": "bar1", }, { "sys_id": "98ace1a537ea2a00cf5c9c9953990e19", "attr1": "foo2", "attr2": "bar2", }, { "sys_id": "a00cf5c9c9953990e1998ace1a537ea2", "attr1": "foo3", "attr2": "bar3", }, ] self.record_response_create = { "sys_id": "90e11a537ea2a00cf598ace9c99539c9", "attr1": "foo_create", "attr2": "bar_create", } self.record_response_update = { "sys_id": "2a00cf5c9c99539998ace1a537ea0e19", "attr1": "foo_updated", "attr2": "bar_updated", } self.record_response_delete = {"status": "record deleted"} self.client_kwargs = { "user": "******", "password": "******", "instance": "mock_instance", } self.attachment = { "sys_id": "attachment_sys_id", "size_bytes": "512", "file_name": "test1.txt", } self.attachment_path = "tests/data/attachment.txt" self.base_path = "/api/now" self.api_path = "/table/incident" self.client = Client(**self.client_kwargs) self.resource = self.client.resource(base_path=self.base_path, api_path=self.api_path) self.mock_url_builder = self.resource._url_builder self.attachment_upload_url = (self.resource._base_url + self.resource._base_path + "/attachment/file") self.mock_url_builder_base = self.resource._url_builder.get_url() self.mock_url_builder_sys_id = self.mock_url_builder.get_appended_custom( "/{0}".format(self.record_response_get_one[0]["sys_id"])) self.dict_query = {"sys_id": self.record_response_get_one[0]["sys_id"]} self.get_fields = ["foo", "bar"] def test_create_resource(self): """:class:`Resource` object repr type should be string, and its path should be set to api_path + base_path """ r = self.client.resource(base_path=self.base_path, api_path=self.api_path) resource_repr = type(repr(r)) self.assertEquals(resource_repr, str) self.assertEquals(r._base_path, self.base_path) self.assertEquals(r._api_path, self.api_path) self.assertEquals(r.path, self.base_path + self.api_path) @httpretty.activate def test_response_headers(self): """Request response headers should be available in Response.headers property""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, status=200, adding_headers={ "x-test-1": "foo", "x-test-2": "bar" }, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertEqual(response.headers["x-test-1"], "foo") self.assertEqual(response.headers["x-test-2"], "bar") @httpretty.activate def test_response_count(self): """:prop:`count` of :class:`pysnow.Response` should raise an exception if count is set to non-integer""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertRaises(TypeError, setattr, response, "count", "foo") self.assertRaises(TypeError, setattr, response, "count", True) self.assertRaises(TypeError, setattr, response, "count", {"foo": "bar"}) @httpretty.activate def test_response_error(self): """:class:`pysnow.Response` should raise an exception if an error is encountered in the response body""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_error(self.error_message_body), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) expected_str = "Error in response. Message: %s, Details: %s" % ( self.error_message_body["message"], self.error_message_body["detail"], ) try: response.first() except ResponseError as e: self.assertEquals(str(e), expected_str) @httpretty.activate def test_get_request_fields(self): """:meth:`get_request` should return a :class:`pysnow.Response` object""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, fields=self.get_fields) qs = qs_as_dict(response._response.request.url) str_fields = ",".join(self.get_fields) # List of fields should end up as comma-separated string self.assertEquals(type(response), Response) self.assertEquals(qs["sysparm_fields"], str_fields) @httpretty.activate def test_get_offset(self): """offset passed to :meth:`get` should set sysparm_offset in query""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) offset = 5 response = self.resource.get(self.dict_query, offset=offset) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs["sysparm_offset"]), offset) @httpretty.activate def test_get_limit(self): """limit passed to :meth:`get` should set sysparm_limit in QS""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) limit = 2 response = self.resource.get(self.dict_query, limit=limit) qs = qs_as_dict(response._response.request.url) self.assertEquals(int(qs["sysparm_limit"]), limit) @httpretty.activate def test_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) result = response.one() self.assertEquals(result["sys_id"], self.record_response_get_one[0]["sys_id"]) @httpretty.activate def test_get_all_empty(self): """:meth:`all` generator of :class:`pysnow.Response` should return an empty list if there are no matches""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) result = list(response.all()) self.assertEquals(result, []) @httpretty.activate def test_get_nocontent(self): """Result.one should raise EmptyContent for GET 202""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=202, content_type="application/json", ) result = self.resource.get(self.dict_query) self.assertRaises(EmptyContent, result.one) @httpretty.activate def test_get_all_single(self): """Single items with all() using the stream parser should return a list containing the item""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_dict), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) result = list(response.all())[0] self.assertEquals(result, self.record_response_get_dict) @httpretty.activate def test_get_buffer_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertRaises(MissingResult, response.one) @httpretty.activate def test_get_stream_missing_result_keys(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if none of the expected keys was found in the result""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=json.dumps({}), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) self.assertRaises(MissingResult, response.first) @httpretty.activate def test_http_error_get_one(self): """:meth:`one` of :class:`pysnow.Response` should raise an HTTPError exception if a non-200 response code was encountered""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, status=500, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertRaises(HTTPError, response.one) @httpretty.activate def test_get_one_many(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if more than one match was found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertRaises(MultipleResults, response.one) @httpretty.activate def test_get_one_empty(self): """:meth:`one` of :class:`pysnow.Response` should raise an exception if no matches were found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) self.assertRaises(NoResults, response.one) @httpretty.activate def test_get_one_or_none_empty(self): """:meth:`one_or_none` of :class:`pysnow.Response` should return `None` if no matches were found """ httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query) result = response.one_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none_empty(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return None if no records were found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, None) @httpretty.activate def test_get_first_or_none(self): """:meth:`first_or_none` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) result = response.first_or_none() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first(self): """:meth:`first` of :class:`pysnow.Response` should return first match if multiple records were found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_three), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) result = response.first() self.assertEquals(result, self.record_response_get_three[0]) @httpretty.activate def test_get_first_empty(self): """:meth:`first` of :class:`pysnow.Response` should raise an exception if matches were found""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result([]), status=200, content_type="application/json", ) response = self.resource.get(self.dict_query, stream=True) self.assertRaises(NoResults, response.first) @httpretty.activate def test_create(self): """:meth:`create` should return a dictionary of the new record""" httpretty.register_uri( httpretty.POST, self.mock_url_builder_base, body=get_serialized_result(self.record_response_create), status=200, content_type="application/json", ) response = self.resource.create(self.record_response_create) self.assertEquals(type(response.one()), dict) self.assertEquals(response.one(), self.record_response_create) @httpretty.activate def test_update(self): """:meth:`update` should return a dictionary of the updated record""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) httpretty.register_uri( httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_update), status=200, content_type="application/json", ) response = self.resource.update(self.dict_query, self.record_response_update) result = response.one() self.assertEquals(type(result), dict) self.assertEquals(self.record_response_update["attr1"], result["attr1"]) @httpretty.activate def test_update_invalid_payload(self): """:meth:`update` should raise an exception if payload is of invalid type""" self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, "foo") self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, False) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, 1) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ("foo", "bar")) self.assertRaises(InvalidUsage, self.resource.update, self.dict_query, ["foo", "bar"]) @httpretty.activate def test_delete(self): """:meth:`delete` should return a dictionary containing status""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) httpretty.register_uri( httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_delete), status=204, content_type="application/json", ) result = self.resource.delete(self.dict_query) self.assertEquals(type(result), dict) self.assertEquals(result["status"], "record deleted") @httpretty.activate def test_delete_chained(self): """:meth:`Response.delete` should return a dictionary containing status""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) httpretty.register_uri( httpretty.DELETE, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_delete), status=204, content_type="application/json", ) result = self.resource.get(query={}).delete() self.assertEquals(type(result), dict) self.assertEquals(result["status"], "record deleted") @httpretty.activate def test_custom(self): """:meth:`custom` should return a :class:`pysnow.Response` object""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) method = "GET" response = self.resource.request(method) self.assertEquals(response._response.request.method, method) self.assertEquals(type(response), Response) @httpretty.activate def test_custom_with_headers(self): """Headers provided to :meth:`custom` should end up in the request""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) headers = {"foo": "bar"} response = self.resource.request("GET", headers=headers) self.assertEquals(response._response.request.headers["foo"], headers["foo"]) @httpretty.activate def test_custom_with_path(self): """path_append passed to :meth:`custom` should get appended to the request path""" path_append = "/foo" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base + path_append, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) response = self.resource.request("GET", path_append="/foo") self.assertEquals(response._response.status_code, 200) @httpretty.activate def test_custom_with_path_invalid(self): """:meth:`custom` should raise an exception if the provided path is invalid""" self.assertRaises(InvalidUsage, self.resource.request, "GET", path_append={"foo": "bar"}) self.assertRaises(InvalidUsage, self.resource.request, "GET", path_append="foo/") self.assertRaises(InvalidUsage, self.resource.request, "GET", path_append=True) @httpretty.activate def test_response_repr(self): """:meth:`get` should result in response obj repr describing the response""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) response = self.resource.get(query={}) response_repr = repr(response) self.assertEquals(response_repr, "<Response [200 - GET]>") def test_attachment_non_table(self): """Accessing `Resource.attachments` from a non-table API should fail""" resource = self.client.resource(base_path=self.base_path, api_path="/invalid") self.assertRaises(InvalidUsage, getattr, resource, "attachments") def test_attachment_type(self): """`Resource.attachments` should be of type Attachment""" attachment_type = type(self.resource.attachments) self.assertEqual(attachment_type, Attachment) def test_get_record_link(self): """`Resource.get_record_link()` should return full URL to the record""" record_link = self.resource.get_record_link( "98ace1a537ea2a00cf5c9c9953990e19") self.assertEqual(record_link, self.mock_url_builder_sys_id) @httpretty.activate def test_get_response_item(self): """Accessing the response as a dict should work""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) response = self.resource.get(query={}) self.assertEquals(response["sys_id"], self.record_response_get_one[0].get("sys_id")) @httpretty.activate def test_get_buffered_first(self): """Using Response.first() without stream=True should fail""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) response = self.resource.get(query={}) self.assertRaises(InvalidUsage, response.first) @httpretty.activate def test_response_update(self): """Using Response.update should update the queried record""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) httpretty.register_uri( httpretty.PUT, self.mock_url_builder_sys_id, body=get_serialized_result(self.record_response_update), status=200, content_type="application/json", ) response = self.resource.get(query={}).update( self.record_response_update) self.assertEqual(self.record_response_update["sys_id"], response["sys_id"]) @httpretty.activate def test_response_upload(self): """Using Response.upload() should attach the file to the queried record and return metadata""" httpretty.register_uri( httpretty.GET, self.mock_url_builder_base, body=get_serialized_result(self.record_response_get_one), status=200, content_type="application/json", ) httpretty.register_uri( httpretty.POST, self.attachment_upload_url, body=get_serialized_result(self.attachment), status=201, content_type="application/json", ) response = self.resource.get(query={}).upload( file_path=self.attachment_path) self.assertEqual(self.attachment["file_name"], response["file_name"])