def __enter__(self): """ Defines the behaviour for __enter__ :return: no return """ HTTPretty.enable()
def start(cls, fixtures): """Start running this class' fixtures""" # If we can't iterate over our fixtures, complain and leave if not hasattr(fixtures, '__iter__'): raise TypeError('Expected `fixtures` to be an iterable sequence but it was not. ' 'Please make it a list or a tuple.') # Keep track if HTTPretty was started outside of FixtureManager # This means that we should not auto-disable HTTPretty when nested_count returns to 0 if FixtureManager.nested_count == 0: FixtureManager.httpretty_enabled_at_start = HTTPretty.is_enabled() # Increase our internal counter # DEV: Keep count on our base class so the `nested_count` is "global" for all subclasses FixtureManager.nested_count += 1 # If HTTPretty hasn't been started yet, then reset its info and start it if not HTTPretty.is_enabled(): HTTPretty.reset() HTTPretty.enable() # Initialize our class instance = cls() # Start each of our fixtures # DEV: We must use a separate function to closure `fixture` to prevent reuse in loops for fixture_key in fixtures: instance.start_fixture(fixture_key) # Return our generated server return instance
def setUp(self): self.region = RegionInfo( name='cc-zone-1', endpoint='mockservice.cc-zone-1.amazonaws.com', connection_cls=MockAWSService) HTTPretty.enable()
def mocked_urls(url_files, methods=None): """mocks the underlying python sockets library to return a given file's content """ # if environment variable is set, then don't mock the tests just grab files # over the network. Example: # env ULMO_DONT_MOCK_TESTS=1 py.test if os.environ.get('ULMO_DONT_MOCK_TESTS', False): yield else: if isinstance(url_files, basestring): url_files = {'.*': url_files} HTTPretty.enable() for url_match, url_file in url_files.iteritems(): if not isinstance(url_match, basestring) and len(url_match) == 2: url_match, methods = url_match if not os.path.isabs(url_file): url_file = get_test_file_path(url_file) callback = _build_request_callback(url_file) url_re = re.compile(url_match) if methods is None: methods = ['GET', 'POST', 'HEAD'] for method in methods: request_class = getattr(HTTPretty, method) HTTPretty.register_uri(request_class, url_re, body=callback) yield HTTPretty.disable() HTTPretty.reset()
def setup_class(cls): cls.token_api_client = TokenAPI_Client(url=IDENTITY_ENDPOINT_URL, auth_token="AUTH_TOKEN", serialize_format="json", deserialize_format="json") HTTPretty.enable()
def setUp(self): HTTPretty.enable() self.strategy = TestStrategy(self.backend, TestStorage) User.reset_cache() TestUserSocialAuth.reset_cache() TestNonce.reset_cache() TestAssociation.reset_cache()
def test_fake_socket_passes_through_gettimeout(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.gettimeout).called_with().should_not.throw(AttributeError) s.truesock.gettimeout.assert_called_with()
def setUp(self): # monkey patch Django's send_mail() function for fun & profit! # We must patch the name of the function relative to the module that # is using it (kittens.views), NOT at the source (django.core.mail). # autospec will enforce a signature check on all function calls. self.send_mail_patcher = patch( 'testtrick.apps.kittens.views.send_mail', autospec=True) self.mock_send_mail = self.send_mail_patcher.start() # create a fake object to use as a return value from our patched # function. it is silly to mock an integer, but this is intended # to demonstrate the use of Mock objects in concert with monkey # patching. This would make more sense if send_mail() returned an # object or anything more complex than an integer primitive send_mail_return_mock = MagicMock(return_value=1) # set the return value on the mock send_mail function to be our integer self.mock_send_mail.return_value = int(send_mail_return_mock) # Mock out our reddit API endpoint HTTPretty.enable() HTTPretty.allow_net_connect = False HTTPretty.register_uri( HTTPretty.GET, "http://www.reddit.com/r/Awww/search/.json", body=MOCK_RESPONSE, content_type='application/json')
def start(cls, fixtures): """Start running this class' fixtures""" # If we can't iterate over our fixtures, complain and leave if not hasattr(fixtures, '__iter__'): raise TypeError( 'Expected `fixtures` to be an iterable sequence but it was not. ' 'Please make it a list or a tuple.') # Keep track if HTTPretty was started outside of FixtureManager # This means that we should not auto-disable HTTPretty when nested_count returns to 0 if FixtureManager.nested_count == 0: FixtureManager.httpretty_enabled_at_start = HTTPretty.is_enabled() # Increase our internal counter # DEV: Keep count on our base class so the `nested_count` is "global" for all subclasses FixtureManager.nested_count += 1 # If HTTPretty hasn't been started yet, then reset its info and start it if not HTTPretty.is_enabled(): HTTPretty.reset() HTTPretty.enable() # Initialize our class instance = cls() # Start each of our fixtures # DEV: We must use a separate function to closure `fixture` to prevent reuse in loops for fixture_key in fixtures: instance.start_fixture(fixture_key) # Return our generated server return instance
def test_global_boolean_enabled(): HTTPretty.disable() expect(HTTPretty.is_enabled()).to.be.falsy HTTPretty.enable() expect(HTTPretty.is_enabled()).to.be.truthy HTTPretty.disable() expect(HTTPretty.is_enabled()).to.be.falsy
def setup_class(cls): cls.raw_image_str = open( os.path.join(os.path.dirname(__file__), 'data/image.json')).read() cls.raw_images_str = open( os.path.join(os.path.dirname(__file__), 'data/images.json')).read() cls.raw_images_schema_str = open( os.path.join(os.path.dirname(__file__), 'data/images_schema.json')).read() cls.raw_image_schema_str = open( os.path.join(os.path.dirname(__file__), 'data/image_schema.json')).read() if IS_MOCK: HTTPretty.enable() cls.mock_api() cls.image_obj = Image._json_to_obj(cls.raw_image_str) cls.images_obj = Image._json_to_obj(cls.raw_images_str) cls.images_client = ImagesClient( base_url='http://localhost/v2', auth_token='36a04b4e71484ab9aacb1d0ac95733fc', serialize_format='json', deserialize_format='json')
def test_socktype_good_python_version(): import socket with patch("socket.SocketType", socket.socket): HTTPretty.enable() expect(socket.SocketType).to.equal(socket.socket) HTTPretty.disable()
def test_httpretty_bypasses_when_disabled(): u"HTTPretty should bypass all requests by disabling it" HTTPretty.register_uri(HTTPretty.GET, "http://localhost:9999/go-for-bubbles/", body="glub glub") HTTPretty.disable() fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/') got1 = fd.read() fd.close() assert that(got1).equals( '. o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o .') fd = urllib2.urlopen('http://localhost:9999/come-again/') got2 = fd.read() fd.close() assert that(got2).equals('<- HELLO WORLD ->') HTTPretty.enable() fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/') got3 = fd.read() fd.close() assert that(got3).equals('glub glub')
def setUp(self): """ Set stuff up """ self.item_doc = self.get_doc('item_doc.json') self.items_doc = self.get_doc('items_doc.json') self.item_versions = self.get_doc('item_versions.json') self.collection_versions = self.get_doc('collection_versions.json') self.collections_doc = self.get_doc('collections_doc.json') self.collection_doc = self.get_doc('collection_doc.json') self.citation_doc = self.get_doc('citation_doc.xml') # self.biblio_doc = self.get_doc('bib_doc.xml') self.attachments_doc = self.get_doc('attachments_doc.json') self.tags_doc = self.get_doc('tags_doc.json') self.groups_doc = self.get_doc('groups_doc.json') self.item_templt = self.get_doc('item_template.json') self.item_types = self.get_doc('item_types.json') self.item_fields = self.get_doc('item_fields.json') self.keys_response = self.get_doc('keys_doc.txt') self.creation_doc = self.get_doc('creation_doc.json') self.item_file = self.get_doc('item_file.pdf') # Add the item file to the mock response by default HTTPretty.enable() HTTPretty.register_uri( HTTPretty.GET, 'https://api.zotero.org/users/myuserID/items', content_type='application/json', body=self.items_doc)
def test_fake_socket_passes_through_setblocking(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.setblocking).called_with(0).should_not.throw(AttributeError) s.truesock.setblocking.assert_called_with(0)
def setUp(self): self.url = IDENTITY_ENDPOINT_URL self.serialize_format = "json" self.deserialize_format = "json" self.auth_token = "AUTH_TOKEN" self.admin_extensions = "OS-KSADM" self.tenant_api_client = TenantsAPI_Client( url=self.url, auth_token=self.auth_token, serialize_format=self.serialize_format, deserialize_format=self.deserialize_format) self.tenant_id = "TENANT_ID" self.tenants_url = "{0}/v2.0/tenants".format(self.url) self.tenant_url = "{0}/v2.0/tenants/{1}".format(self.url, self.tenant_id) self.user_id = "USER_ID" self.users_url = "{0}/v2.0/users".format(self.url) self.user_url = "{0}/{1}".format(self.users_url, self.user_id) self.tenant_users_url = "{0}/users".format(self.tenant_url) self.user_role_url = "{0}/{1}/roles".format(self.tenant_users_url, self.user_id) self.role_id = "ROLE_ID" self.tenant_user_role_url = "{0}/{1}/{2}".format(self.user_role_url, self.admin_extensions, self.role_id) HTTPretty.enable()
def test_fake_socket_passes_through_shutdown(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.shutdown).called_with(socket.SHUT_RD).should_not.throw(AttributeError) s.truesock.shutdown.assert_called_with(socket.SHUT_RD)
def test_httpretty_bypasses_when_disabled(context): u"HTTPretty should bypass all requests by disabling it" HTTPretty.register_uri( HTTPretty.GET, "http://localhost:9999/go-for-bubbles/", body="glub glub") HTTPretty.disable() fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/') got1 = fd.read() fd.close() expect(got1).to.equal( '. o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o .') fd = urllib2.urlopen('http://localhost:9999/come-again/') got2 = fd.read() fd.close() expect(got2).to.equal('<- HELLO WORLD ->') HTTPretty.enable() fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/') got3 = fd.read() fd.close() expect(got3).to.equal('glub glub')
def test_fake_socket_passes_through_getpeername(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.getpeername).called_with().should_not.throw(AttributeError) s.truesock.getpeername.assert_called_with()
def setup_class(cls): cls.token_api_client = TokenAPI_Client( url=IDENTITY_ENDPOINT_URL, auth_token="AUTH_TOKEN", serialize_format="json", deserialize_format="json") HTTPretty.enable()
def setUp(self): HTTPretty.enable() HTTPretty.register_uri( HTTPretty.POST, ("http://doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com/" "2011-02-01/documents/batch"), body=json.dumps(self.response).encode('utf-8'), content_type="application/json")
def test_fake_socket_passes_through_bind(): import socket HTTPretty.enable() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.truesock = MagicMock() expect(s.bind).called_with( ('127.0.0.1', 1000)).should_not.throw(AttributeError) s.truesock.bind.assert_called_with(('127.0.0.1', 1000))
def setUp(self): HTTPretty.enable() HTTPretty.register_uri( HTTPretty.POST, ("http://doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com/" "2011-02-01/documents/batch"), body=json.dumps(self.response), content_type="application/json")
def setUp(self): HTTPretty.enable() User.reset_cache() TestUserSocialAuth.reset_cache() TestNonce.reset_cache() TestAssociation.reset_cache() self.backend = module_member('social.backends.github.GithubOAuth2') self.strategy = TestStrategy(self.backend, TestStorage) self.user = None
def setUp(self): HTTPretty.enable() self.backend = module_member(self.backend_path) self.complete_url = "/complete/{0}/".format(self.backend.name) self.strategy = TestStrategy(self.backend, TestStorage, redirect_uri=self.complete_url) self.strategy.set_settings( {"SOCIAL_AUTH_AUTHENTICATION_BACKENDS": (self.backend_path, "tests.backends.broken_test.BrokenBackendAuth")} ) # Force backends loading to trash PSA cache load_backends(self.strategy.get_setting("SOCIAL_AUTH_AUTHENTICATION_BACKENDS"), force_load=True)
def setUp(self): HTTPretty.enable() User.reset_cache() TestUserSocialAuth.reset_cache() TestNonce.reset_cache() TestAssociation.reset_cache() Backend = module_member("social.backends.github.GithubOAuth2") self.strategy = self.strategy or TestStrategy(TestStorage) self.backend = Backend(self.strategy, redirect_uri="/complete/github") self.user = None
def wrapper(*args, **kwargs): HTTPretty.reset() HTTPretty.enable() _do_httpretty_registration(path) try: return func(*args, **kwargs) finally: HTTPretty.disable()
def setUp(self): HTTPretty.enable() User.reset_cache() TestUserSocialAuth.reset_cache() TestNonce.reset_cache() TestAssociation.reset_cache() Backend = module_member('social_core.backends.github.GithubOAuth2') self.strategy = self.strategy or TestStrategy(TestStorage) self.backend = Backend(self.strategy, redirect_uri='/complete/github') self.user = None
def setUp(self): HTTPretty.enable() body = self.response if not isinstance(body, basestring): body = json.dumps(body) HTTPretty.register_uri(HTTPretty.GET, FULL_URL, body=body, content_type=self.content_type, status=self.response_status)
def setUp(self): HTTPretty.enable() body = self.response if not isinstance(body, bytes): body = json.dumps(body).encode('utf-8') HTTPretty.register_uri(HTTPretty.GET, FULL_URL, body=body, content_type=self.content_type, status=self.response_status)
def test_latest_subject_positions(self): message = self._skeleton_message() RoomPosition().process_message(message) path = 'latest_subject_positions/%s' % message['sensor_id'] full_path = "http://127.0.0.1:8000/%s" % path HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, full_path) response = requests.get(full_path) HTTPretty.disable() eq_(response.status_code, STATUS_OK, 'Response has status_code: %s' % response.status_code)
def setUp(self): ''' Mock-out our Reddit API endpoint. ''' self.kitten_email_subject = "You've received a kitten!" HTTPretty.enable() HTTPretty.allow_net_connect = False HTTPretty.register_uri( HTTPretty.GET, "http://www.reddit.com/r/Awww/search/.json", body=MOCK_RESPONSE, content_type='application/json')
def test_socktype_bad_python_version_regression(): """ Some versions of python accidentally internally shadowed the SockType variable, so it was no longer the socket object but and int Enum representing the socket type e.g. AF_INET. Make sure we don't patch SockType in these cases https://bugs.python.org/issue20386 """ import socket someObject = object() with patch('socket.SocketType', someObject): HTTPretty.enable() expect(socket.SocketType).to.equal(someObject) HTTPretty.disable()
def setup_class(cls): HTTPretty.enable() cls.images_client = ImagesClient( url=GLANCE_API_SERVER_ENDPOINT, auth_token="36a04b4e71484ab9aacb1d0ac95733fc", serialize_format="json", deserialize_format="json") cls.image_id = '1c675abd94f49cda114e12490b328d9' cls.images_uri = '{0}/images'.format(GLANCE_API_SERVER_ENDPOINT) cls.image_uri = '{0}/{1}'.format(cls.images_uri, cls.image_id)
def start(self): self.backend.reset() HTTPretty.enable() for method in HTTPretty.METHODS: for key, value in self.backend.urls.iteritems(): HTTPretty.register_uri(method=method, uri=re.compile(key), body=value) # Mock out localhost instance metadata HTTPretty.register_uri( method=method, uri=re.compile("http://169.254.169.254/latest/meta-data/.*"), body=metadata_response )
def setUp(self): self.dir_name = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data') HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, "http://fooimages.org/image1.png", body="foo") HTTPretty.register_uri(HTTPretty.GET, "http://foofiles.org/text1.txt", body="foo") HTTPretty.register_uri(HTTPretty.GET, "http://foofiles.org/text2.txt", body="foo") f = open(os.path.join(self.dir_name, 'page.html')) self.html = f.read() f.close()
def test_unix_socket(): import socket HTTPretty.enable() # Create a UDS socket sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) server_address = './not-exist-socket' try: sock.connect(server_address) except socket.error: # We expect this, since the server_address does not exist pass
def setup_class(cls): HTTPretty.enable() cls.images_client = ImagesClient( url=GLANCE_API_SERVER_ENDPOINT, auth_token="36a04b4e71484ab9aacb1d0ac95733fc", serialize_format="json", deserialize_format="json" ) cls.image_id = '1c675abd94f49cda114e12490b328d9' cls.images_uri = '{0}/images'.format(GLANCE_API_SERVER_ENDPOINT) cls.image_uri = '{0}/{1}'.format(cls.images_uri, cls.image_id)
def start(self): """Starts the mocked context by enabling HTTPretty to route requests to the defined endpoints. """ from .endpoints import clear_endpoints self.started = True clear_endpoints() clear_backends() if not HTTPretty.is_enabled(): HTTPretty.enable() self._register()
def mocked_urls(url_files, methods=None): """mocks the underlying python sockets library to return a given file's content. Note: that this function checks for an environment variable named ULMO_DONT_MOCK_TESTS; if that environment variable is set then urls will not be mocked and the HTTP requests will go over the network. For example, this could be used to to run the whole test suite without mocking files: # env ULMO_DONT_MOCK_TESTS=1 py.test Parameters ---------- url_files : str or dict Files to be mocked. It can either be a string representation of a filepath to a file whose contents will be used as a response to all HTTP requests. Or it can be a dict where the keys are regular expression strings and the values are filepaths - the regex keys will be used to match urls if they match, the file path will be used. methods : iterable of str or None HTTP methods that will be mocked. If set to None (default) then the default methods are GET, POST and HEAD. """ if os.environ.get('ULMO_DONT_MOCK_TESTS', False): yield else: if isinstance(url_files, basestring): url_files = {'.*': url_files} HTTPretty.enable() for url_match, url_file in url_files.iteritems(): if not isinstance(url_match, basestring) and len(url_match) == 2: url_match, methods = url_match if not os.path.isabs(url_file): url_file = get_test_file_path(url_file) callback = _build_request_callback(url_file) url_re = re.compile(url_match) if methods is None: methods = ['GET', 'POST', 'HEAD'] for method in methods: request_class = getattr(HTTPretty, method) HTTPretty.register_uri(request_class, url_re, match_querystring=True, body=callback) yield HTTPretty.disable() HTTPretty.reset()
def mocked_urls(url_files, methods=None, force=False): """mocks the underlying python sockets library to return a given file's content. Note: that this function checks for an environment variable named ULMO_DONT_MOCK_TESTS; if that environment variable is set then urls will not be mocked and the HTTP requests will go over the network. For example, this could be used to to run the whole test suite without mocking files: # env ULMO_DONT_MOCK_TESTS=1 py.test Parameters ---------- url_files : str or dict Files to be mocked. It can either be a string representation of a filepath to a file whose contents will be used as a response to all HTTP requests. Or it can be a dict where the keys are regular expression strings and the values are filepaths - the regex keys will be used to match urls if they match, the file path will be used. methods : iterable of str or None HTTP methods that will be mocked. If set to None (default) then the default methods are GET, POST and HEAD. """ # if environment variable is set, then mock the tests otherwise just grab files # over the network. Example: # env ULMO_MOCK_TESTS=1 py.test if not os.environ.get('ULMO_MOCK_TESTS', False) and not force: yield else: if isinstance(url_files, basestring): url_files = {'.*': url_files} HTTPretty.enable() for url_match, url_file in url_files.items(): if not isinstance(url_match, basestring) and len(url_match) == 2: url_match, methods = url_match if not os.path.isabs(url_file): url_file = get_test_file_path(url_file) callback = _build_request_callback(url_file) url_re = re.compile(url_match) if methods is None: methods = ['GET', 'POST', 'HEAD'] for method in methods: request_class = getattr(HTTPretty, method) HTTPretty.register_uri(request_class, url_re, match_querystring=True, body=callback) yield HTTPretty.disable() HTTPretty.reset()
def test_latest_subject_positions(self): # Keep this import here in order to avoid OpenCV imports from pipeline.room_position import RoomPosition message = self._skeleton_message() RoomPosition().process_message(message) path = 'latest_subject_positions/%s' % message['sensor_id'] full_path = "http://127.0.0.1:8000/%s" % path HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, full_path) response = requests.get(full_path) HTTPretty.disable() eq_(response.status_code, STATUS_OK, 'Response has status_code: %s' % response.status_code)
def start_mocking(self): self.__class__._count += 1 self.backend.reset() if not HTTPretty.is_enabled(): HTTPretty.enable() for method in HTTPretty.METHODS: # mock all url to dropbox for any module.... for key, value in self.backend.urls.iteritems(): HTTPretty.register_uri( method=method, uri=re.compile(key), body=value, )
def test_httpretty_should_not_raise_on_socket_send_when_uri_not_registered(): ("HTTPretty should not raise a RuntimeError when the fakesocket " "is used in an invalid usage.") import socket HTTPretty.enable() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0) sock.setblocking(0) expect(sock.sendto).when.called_with( b'whatever', ('127.0.0.1', 53)).should_not.throw(RuntimeError) sock.close() HTTPretty.reset() HTTPretty.disable()
def setUp(self): HTTPretty.enable() Backend = module_member(self.backend_path) self.strategy = TestStrategy(TestStorage) self.complete_url = self.raw_complete_url.format(Backend.name) self.backend = Backend(self.strategy, redirect_uri=self.complete_url) self.strategy.set_settings({ 'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (self.backend_path, 'social_core.tests.backends.test_broken.BrokenBackendAuth') }) # Force backends loading to trash PSA cache load_backends( self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'), force_load=True)
def setUp(self): self.url = IDENTITY_ENDPOINT_URL self.serialized_format = "json" self.deserialized_format = "json" self.auth_token = "AUTH_TOKEN" self.admin_extensions = "OS-KSADM" self.extensions_api_client = ExtensionsAPI_Client( url=self.url, auth_token=self.auth_token, serialized_format=self.serialized_format, deserialized_format=self.deserialized_format) self.role_id = "1" HTTPretty.enable()
def setUp(self): HTTPretty.enable() self.backend = module_member(self.backend_path) self.complete_url = '/complete/{0}/'.format(self.backend.name) self.strategy = TestStrategy(self.backend, TestStorage, redirect_uri=self.complete_url) self.strategy.set_settings({ 'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': ( self.backend_path, 'tests.backends.broken_test.BrokenBackendAuth' ) }) # Force backends loading to trash PSA cache load_backends( self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'), force_load=True )
def setUp(self): HTTPretty.enable() Backend = module_member(self.backend_path) self.strategy = views.load_strategy() self.backend = Backend(self.strategy, redirect_uri=self.complete_url) self.name = self.backend.name.upper().replace('-', '_') self.complete_url = self.strategy.build_absolute_uri( self.raw_complete_url.format(self.backend.name)) backends = (self.backend_path, ) load_backends(backends, force_load=True) user_data_body = json.loads(self.user_data_body) self.email = '*****@*****.**' user_data_body['email'] = self.email self.user_data_body = json.dumps(user_data_body) self.do_rest_login()
def start(self): self.backend.reset() HTTPretty.enable() for method in HTTPretty.METHODS: for key, value in self.backend.urls.iteritems(): HTTPretty.register_uri( method=method, uri=re.compile(key), body=value, ) # Mock out localhost instance metadata HTTPretty.register_uri( method=method, uri=re.compile('http://169.254.169.254/latest/meta-data/.*'), body=metadata_response)
def setUp(self): HTTPretty.enable() self.backend = module_member(self.backend_path) name = self.backend.name self.complete_url = self.raw_complete_url.format(name) self.strategy = TestStrategy(self.backend, TestStorage) name = name.upper().replace('-', '_') self.strategy.set_settings({ 'SOCIAL_AUTH_' + name + '_KEY': 'a-key', 'SOCIAL_AUTH_' + name + '_SECRET': 'a-secret-key', 'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (self.backend_path, 'tests.backends.broken_test.BrokenBackendAuth') }) # Force backends loading to trash PSA cache load_backends( self.strategy.get_setting('SOCIAL_AUTH_AUTHENTICATION_BACKENDS'), force_load=True)
def test_httpretty_should_raise_on_socket_send_when_uri_registered(): """HTTPretty should raise a RuntimeError when the fakesocket is used in an invalid usage. """ import socket HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, 'http://127.0.0.1:5000') expect(core.POTENTIAL_HTTP_PORTS).to.be.equal(set([80, 443, 5000])) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(('127.0.0.1', 5000)) expect(sock.send).when.called_with(b'whatever').to.throw(RuntimeError) sock.close() # restore the previous value core.POTENTIAL_HTTP_PORTS.remove(5000) HTTPretty.reset() HTTPretty.disable()
def test_http_passthrough(): url = 'http://ip4.me/' response1 = requests.get(url) HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, 'http://google.com/', body="Not Google") response2 = requests.get('http://google.com/') expect(response2.content).to.equal(b'Not Google') response3 = requests.get(url) expect(response3.content).to.equal(response1.content) HTTPretty.disable() response4 = requests.get(url) expect(response4.content).to.equal(response1.content)