def test_recover_retry_txn(self): txn = Mock() txns = [txn, None] pop_txn = False def take_txn(*args, **kwargs): if pop_txn: return defer.succeed(txns.pop(0)) else: return defer.succeed(txn) self.store.get_oldest_unsent_txn = Mock(side_effect=take_txn) self.recoverer.recover() self.assertEquals(0, self.store.get_oldest_unsent_txn.call_count) txn.send = Mock(return_value=False) self.clock.advance_time(2) self.assertEquals(1, txn.send.call_count) self.assertEquals(0, txn.complete.call_count) self.assertEquals(0, self.callback.call_count) self.clock.advance_time(4) self.assertEquals(2, txn.send.call_count) self.assertEquals(0, txn.complete.call_count) self.assertEquals(0, self.callback.call_count) self.clock.advance_time(8) self.assertEquals(3, txn.send.call_count) self.assertEquals(0, txn.complete.call_count) self.assertEquals(0, self.callback.call_count) txn.send = Mock(return_value=True) # successfully send the txn pop_txn = True # returns the txn the first time, then no more. self.clock.advance_time(16) self.assertEquals(1, txn.send.call_count) # new mock reset call count self.assertEquals(1, txn.complete.call_count) self.callback.assert_called_once_with(self.recoverer)
def test_custodian_azure_send_override_429_long_retry(self, logger): mock = Mock() mock.send = types.MethodType(custodian_azure_send_override, mock) response_dict = {'headers': {'Retry-After': 60}, 'status_code': 429} mock.orig_send.return_value = type(str('response'), (), response_dict) mock.send('') self.assertEqual(mock.orig_send.call_count, 1) self.assertEqual(logger.call_count, 1)
def test_custodian_azure_send_override_200(self, logger): mock = Mock() mock.send = types.MethodType(custodian_azure_send_override, mock) response_dict = { 'headers': {'x-ms-ratelimit-remaining-subscription-reads': '12000'}, 'status_code': 200 } mock.orig_send.return_value = type(str('response'), (), response_dict) mock.send('') self.assertEqual(mock.orig_send.call_count, 1) self.assertEqual(logger.call_count, 2)
def test_custodian_azure_send_override_429_long_retry(self, logger): mock = Mock() mock.send = types.MethodType(custodian_azure_send_override, mock) response_dict = { 'headers': {'Retry-After': 60}, 'status_code': 429 } mock.orig_send.return_value = type(str('response'), (), response_dict) mock.send('') self.assertEqual(mock.orig_send.call_count, 1) self.assertEqual(logger.call_count, 1)
def setUp(self): job_mock = Mock() job_mock.update = Mock() self.job = job_mock notification_mock = Mock() notification_mock.send = Mock() notification_fail = Mock() notification_fail.send = Mock(side_effect=Exception('something went wrong!')) self.success_notification = notification_mock self.failure_notification = notification_fail
def setUp(self): job_mock = Mock() job_mock.update = Mock() self.job = job_mock notification_mock = Mock() notification_mock.send = Mock() notification_fail = Mock() notification_fail.send = Mock( side_effect=Exception('something went wrong!')) self.success_notification = notification_mock self.failure_notification = notification_fail
def test_custodian_azure_send_override_429_missingheader( self, logger_debug, logger_warning): mock = Mock() mock.send = types.MethodType(custodian_azure_send_override, mock) response_dict = {'headers': {}, 'status_code': 429} mock.orig_send.return_value = type(str('response'), (), response_dict) with patch('time.sleep', new_callable=time.sleep(0)): mock.send('') self.assertEqual(mock.orig_send.call_count, 3) self.assertEqual(logger_debug.call_count, 3) self.assertEqual(logger_warning.call_count, 3)
def test_registration_craps_out(self): from pyramid_signup.views import RegisterController from pyramid_mailer.interfaces import IMailer def send(message): raise Exception("I broke!") mailer = Mock() mailer.send = send self.config.include('pyramid_signup') self.config.registry.registerUtility(mailer, IMailer) self.config.add_route('index', '/') request = self.get_csrf_request(post={ 'Username': '******', 'Password': { 'value': 'test123', 'confirm': 'test123', }, 'Email': '*****@*****.**' }, request_method='POST') flash = Mock() request.session.flash = flash request.user = Mock() controller = RegisterController(request) controller.post() flash.assert_called_with('I broke!', 'error')
def test_source_process(self): source = FilesystemObserverSource('*.txt', '/some/directory') reactor = Mock() reactor.spawnProcess = Mock(spec=_spawnProcess) scheduler = Mock() scheduler.send = Mock(spec=Scheduler.send) # Attach source to the scheduler. yield source.attach(scheduler, reactor) self.assertEquals(reactor.spawnProcess.call_count, 1) # Simulate a message directed to the source. msg = { 'port': 'default', 'item': { 'type': 'delta', 'date': datetime(2010, 10, 20, 20, 10), 'inserts': ['abcdefg'], 'deletes': ['hiklmno'], 'data': { 'abcdefg': { 'path': '/some/directory/xyz.txt' } } } } matches = MatchesSendDeltaItemInvocation(copy.deepcopy(msg['item']), source) source.peer.dataReceived(BSON.encode(msg)) self.assertEquals(scheduler.send.call_count, 1) self.assertThat(scheduler.send.call_args, matches)
def test_source_process(self): source = FilesystemObserverSource("*.txt", "/some/directory") reactor = Mock() reactor.spawnProcess = Mock(spec=_spawnProcess) scheduler = Mock() scheduler.send = Mock(spec=Scheduler.send) # Attach source to the scheduler. yield source.attach(scheduler, reactor) self.assertEquals(reactor.spawnProcess.call_count, 1) # Simulate a message directed to the source. msg = { "port": "default", "item": { "type": "delta", "date": datetime(2010, 10, 20, 20, 10), "inserts": ["abcdefg"], "deletes": ["hiklmno"], "data": {"abcdefg": {"path": "/some/directory/xyz.txt"}}, }, } matches = MatchesSendDeltaItemInvocation(copy.deepcopy(msg["item"]), source) source.peer.dataReceived(BSON.encode(msg)) self.assertEquals(scheduler.send.call_count, 1) self.assertThat(scheduler.send.call_args, matches)
def test_registration_craps_out(self): from horus.views import RegisterController from pyramid_mailer.interfaces import IMailer from horus.interfaces import IUserClass from horus.tests.models import User from horus.interfaces import IActivationClass from horus.tests.models import Activation self.config.registry.registerUtility(Activation, IActivationClass) self.config.registry.registerUtility(User, IUserClass) def send(message): raise Exception("I broke!") mailer = Mock() mailer.send = send self.config.include('horus') self.config.registry.registerUtility(mailer, IMailer) self.config.add_route('index', '/') request = self.get_csrf_request(post={ 'username': '******', 'password': { 'password': '******', 'password-confirm': 'test123', }, 'email': '*****@*****.**' }, request_method='POST') request.user = Mock() controller = RegisterController(request) self.assertRaises(Exception, controller.register)
def test_get_http_error(self, mock_session_class): """ test ensures that exception is captured and does not impede """ mock_result = mock.Mock(name="mock_result") mock_result.status_code = 500 mock_result.text = "error" mock_session = Mock(name="mock_session") mock_session.send = Mock(return_value=mock_result, name="mock_session.send") mock_session.side_effect = requests.exceptions.HTTPError() mock_session.prepare_request = mock_prepare_request mock_session.hooks = {"response": []} mock_session_class.return_value = mock_session # We need to patch only Session in this case self.requests_patcher.stop() self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.bios.version": "4.2.amazon" }) facts = self.collector.get_all() self.assertNotIn("aws_instance_id", facts)
def test_get_gcp_facts(self, mock_get_metadata_from_cache, mock_write_token_to_cache_file): """ Test getting GCP instance ID from metadata provided by GCP cloud provider """ self.requests_mock.Request = Mock(name="mock_Request") mock_result = Mock(name="mock_result") mock_result.status_code = 200 mock_result.text = GCP_JWT_TOKEN mock_session = Mock(name="mock_session") mock_session.send = Mock(return_value=mock_result, name="mock_send") mock_session.prepare_request = Mock(name="mock_prepare_request") mock_session.hooks = {"response": []} self.requests_mock.Session = Mock(return_value=mock_session, name="mock_Session") mock_get_metadata_from_cache.return_value = None mock_write_token_to_cache_file.return_value = None self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.bios.vendor": "google" }) facts = self.collector.get_all() self.assertIn("gcp_instance_id", facts) self.assertEqual(facts["gcp_instance_id"], "2589221140676718026")
def test_get_azure_facts(self): """ Test getting Azure facts instance ID (vmId) from metadata provided by Azure cloud provider """ self.requests_mock.Request = Mock(name="mock_Request") mock_result = Mock(name="mock_result") mock_result.status_code = 200 mock_result.text = AZURE_METADATA mock_session = Mock(name="mock_session") mock_session.send = Mock(return_value=mock_result, name="mock_send") mock_session.prepare_request = Mock(name="mock_prepare_request") mock_session.hooks = {"response": []} self.requests_mock.Session = Mock(return_value=mock_session, name="mock_Session") self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.chassis.asset_tag": "7783-7084-3265-9085-8269-3286-77", }) facts = self.collector.get_all() # azure_instance_id should be included in the facts self.assertIn("azure_instance_id", facts) self.assertEqual(facts["azure_instance_id"], AZURE_INSTANCE_ID) # some other azure facts should be included in facts too self.assertIn("azure_sku", facts) self.assertEqual(facts["azure_sku"], AZURE_SKU) self.assertIn("azure_offer", facts) self.assertEqual(facts["azure_offer"], AZURE_OFFER)
def test_get_aws_facts(self, mock_session_class): """ Test getting AWS facts (instance ID, accountID and billingProducts) """ mock_result = Mock(name="_test_get_aws_facts.mock_result") mock_result.status_code = 200 mock_result.text = AWS_METADATA mock_session = Mock(name="_test_get_aws_facts.mock_session") mock_session.send = Mock(return_value=mock_result, name="_test_get_aws_facts.mock_session.send") mock_session.prepare_request = mock_prepare_request mock_session.hooks = {"response": []} mock_session_class.return_value = mock_session # We need to patch only Session in this case self.requests_patcher.stop() self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.bios.version": "4.2.amazon" }) facts = self.collector.get_all() self.assertIn("aws_instance_id", facts) self.assertEqual(facts["aws_instance_id"], AWS_INSTANCE_ID) self.assertIn("aws_account_id", facts) self.assertEqual(facts["aws_account_id"], AWS_ACCOUNT_ID) self.assertIn("aws_billing_products", facts) self.assertEqual(facts["aws_billing_products"], AWS_BILLING_PRODUCTS) self.assertIn("aws_marketplace_product_codes", facts) self.assertEqual(facts["aws_marketplace_product_codes"], None)
def setup_method(self): socket = Mock() socket.recv = Mock() socket.send = Mock() with patch("socket.create_connection") as create_connection: create_connection.return_value = socket self.connection = TCPSocketConnection(("localhost", 1234))
def setUp(self): socket = Mock() socket.recv = Mock() socket.send = Mock() with patch("socket.create_connection") as create_connection: create_connection.return_value = socket self.connection = TCPSocketConnection(("localhost", 1234))
def test_single_service_up_txn_not_sent(self): # Test: The AS is up and the txn is not sent. A Recoverer is made and # started. service = Mock() events = [Mock(), Mock()] txn_id = "foobar" txn = Mock(id=txn_id, service=service, events=events) # mock methods self.store.get_appservice_state = Mock( return_value=defer.succeed(ApplicationServiceState.UP) ) self.store.set_appservice_state = Mock(return_value=defer.succeed(True)) txn.send = Mock(return_value=defer.succeed(False)) # fails to send self.store.create_appservice_txn = Mock( return_value=defer.succeed(txn) ) # actual call self.txnctrl.send(service, events) self.store.create_appservice_txn.assert_called_once_with( service=service, events=events ) self.assertEquals(1, self.recoverer_fn.call_count) # recoverer made self.assertEquals(1, self.recoverer.recover.call_count) # and invoked self.assertEquals(1, len(self.txnctrl.recoverers)) # and stored self.assertEquals(0, txn.complete.call_count) # txn not completed self.store.set_appservice_state.assert_called_once_with( service, ApplicationServiceState.DOWN # service marked as down )
def test_registration_craps_out(self): from pyramid_signup.views import RegisterController from pyramid_mailer.interfaces import IMailer def send(message): raise Exception("I broke!") mailer = Mock() mailer.send = send self.config.include('pyramid_signup') self.config.registry.registerUtility(mailer, IMailer) self.config.add_route('index', '/') request = self.get_csrf_request(post={ 'Username': '******', 'Password': { 'value': 'test123', 'confirm': 'test123', }, 'Email': '*****@*****.**' }, request_method='POST') flash = Mock() request.session.flash = flash request.user = Mock() controller = RegisterController(request) controller.register() flash.assert_called_with('I broke!', 'error')
def test_create_user(): #setup parameters = {'email': '*****@*****.**', 'display_name': 'test_name'} expected = User(**parameters) mail_params = { 'subject': 'Welcome the WDL Fantasy League!', 'sender': app.config.get("MAIL_USERNAME"), 'recipients': [parameters['email']], 'html': '<h1>Welcome to the WDL Fantasy League, {}!</h1>'.format(parameters['display_name'])\ + '<p>Your id is {}</p>'.format(expected._id)\ + '<p>and your link is http://whodunnitleague.com/fantasy/team.html?id={}'.format(expected._id) } mocked_message = Mock() mocked_message_class = Mock(return_value=mocked_message) mocked_mail = Mock() mocked_mail.send = Mock() module.mail = mocked_mail module.Message = mocked_message_class with app.app_context(): current_app.user_service = Mock() current_app.user_service.create_user = Mock() #functionality r = client.post('/users/', data=json.dumps(parameters)) #test with app.app_context(): current_app.user_service.create_user\ .assert_called_with(expected) mocked_message_class.assert_called_with(**mail_params) mocked_mail.send.assert_called_with(mocked_message) assert r.get_data() == json.dumps(dict(expected)) assert r.status_code == 201
def test_quit_bot(self): from functions import quit_bot with nested( patch('functions.log_write'), patch('sys.stdout', new=StringIO()), patch('functions.get_datetime'), ) as (log_write, stdout, get_dt): get_dt.return_value = {'date': '42', 'time': '42'} s = Mock() s.send.side_effect = IOError() message = 'Unexpected error while quitting: \n' self.assertFalse(quit_bot(s, 'foo')) self.assertEqual(stdout.getvalue(), message) log_write.assert_called_with('foo', '42', ' <> ', message) s.send.side_effect = None s.send = Mock() self.assertTrue(quit_bot(s, 'foo')) log_write.assert_called_with('foo', '42', ' <> ', 'QUIT\r\n') s.send.assert_called_with('QUIT\r\n')
def test_collect_cloud_info_more_cloud_providers_detected( self, mock_session_class): """ Test the case, when we try to collect cloud info only for more than one cloud providers, because more than one cloud providers were detected """ mock_session = Mock() mock_session.send = send_only_imds_v2_is_supported mock_session.prepare_request = Mock(side_effect=mock_prepare_request) mock_session.hooks = {"response": []} mock_session_class.return_value = mock_session # More cloud providers detected cloud_list = ["azure", "aws"] cloud_info = _collect_cloud_info(cloud_list, Mock()) self.assertIsNotNone(cloud_info) self.assertTrue(len(cloud_info) > 0) self.assertTrue("cloud_id" in cloud_info) self.assertEqual(cloud_info["cloud_id"], "aws") # Test metadata self.assertTrue("metadata" in cloud_info) b64_metadata = cloud_info["metadata"] metadata = base64.b64decode(b64_metadata).decode("utf-8") self.assertEqual(metadata, AWS_METADATA) # Test signature self.assertTrue("signature" in cloud_info) b64_signature = cloud_info["signature"] signature = base64.b64decode(b64_signature).decode("utf-8") self.assertEqual( signature, "-----BEGIN PKCS7-----\n" + AWS_SIGNATURE + "\n-----END PKCS7-----")
def test_single_service_up_txn_not_sent(self): # Test: The AS is up and the txn is not sent. A Recoverer is made and # started. service = Mock() events = [Mock(), Mock()] txn_id = "foobar" txn = Mock(id=txn_id, service=service, events=events) # mock methods self.store.get_appservice_state = Mock( return_value=defer.succeed(ApplicationServiceState.UP)) self.store.set_appservice_state = Mock( return_value=defer.succeed(True)) txn.send = Mock(return_value=defer.succeed(False)) # fails to send self.store.create_appservice_txn = Mock( return_value=defer.succeed(txn)) # actual call self.txnctrl.send(service, events) self.store.create_appservice_txn.assert_called_once_with( service=service, events=events) self.assertEquals(1, self.recoverer_fn.call_count) # recoverer made self.assertEquals(1, self.recoverer.recover.call_count) # and invoked self.assertEquals(1, len(self.txnctrl.recoverers)) # and stored self.assertEquals(0, txn.complete.call_count) # txn not completed self.store.set_appservice_state.assert_called_once_with( service, ApplicationServiceState.DOWN # service marked as down )
def test_submit_run_file_not_found(self, isfile_mock): client = Mock() client.send = Mock(return_value=None) inst_mon = InstrumentMonitor(client, 'WISH') inst_mon.data_dir = '/my/data/dir' data_loc = os.path.join(inst_mon.data_dir, CYCLE_FOLDER, FILE_NAME) with self.assertRaises(FileNotFoundError): inst_mon.submit_run(RUN_DATA['summary_rb_number'], RUN_DATA['run_number'], FILE_NAME) isfile_mock.assert_called_with(data_loc)
def test_get_aws_facts_with_null_billing_products(self, mock_session_class): """ Billing products could be null in some cases (not RHEL) """ mock_result = Mock(name="mock_result") mock_result.status_code = 200 mock_result.text = """ { "accountId" : "012345678900", "architecture" : "x86_64", "availabilityZone" : "eu-central-1b", "billingProducts" : null, "devpayProductCodes" : null, "marketplaceProductCodes" : null, "imageId" : "ami-0123456789abcdeff", "instanceId" : "i-abcdef01234567890", "instanceType" : "m5.large", "kernelId" : null, "pendingTime" : "2020-02-02T02:02:02Z", "privateIp" : "12.34.56.78", "ramdiskId" : null, "region" : "eu-central-1", "version" : "2017-09-30" } """ mock_session = Mock(name="mock_session") mock_session.send = Mock(return_value=mock_result, name="mock_session.send") mock_session.prepare_request = mock_prepare_request mock_session.hooks = {"response": []} mock_session_class.return_value = mock_session # We need to patch only Session in this case self.requests_patcher.stop() self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.bios.version": "4.2.amazon" }) facts = self.collector.get_all() self.assertIn("aws_instance_id", facts) self.assertEqual(facts["aws_instance_id"], AWS_INSTANCE_ID) self.assertIn("aws_account_id", facts) self.assertEqual(facts["aws_account_id"], AWS_ACCOUNT_ID) self.assertIn("aws_billing_products", facts) self.assertEqual(facts["aws_billing_products"], None) self.assertIn("aws_marketplace_product_codes", facts) self.assertEqual(facts["aws_marketplace_product_codes"], None)
def test_handle_response_401(self): # Get a 401 from server, authenticate, and get a 200 back. with patch.multiple(kerberos_module_name, authGSSClientInit=clientInit_complete, authGSSClientResponse=clientResponse, authGSSClientStep=clientStep_continue): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_kerberos.HTTPKerberosAuth() auth.handle_other = Mock(return_value=response_ok) r = auth.handle_response(response) self.assertTrue(response in r.history) auth.handle_other.assert_called_once_with(response_ok) self.assertEqual(r, response_ok) self.assertEqual( request.headers['Authorization'], 'Negotiate GSSRESPONSE') connection.send.assert_called_with(request) raw.release_conn.assert_called_with() clientInit_complete.assert_called_with( "*****@*****.**", gssflags=( kerberos.GSS_C_MUTUAL_FLAG | kerberos.GSS_C_SEQUENCE_FLAG), principal=None) clientStep_continue.assert_called_with("CTX", "token") clientResponse.assert_called_with("CTX")
def test_handle_response_401(self): # Get a 401 from server, authenticate, and get a 200 back. with patch.multiple("gssapi.SecurityContext", __init__=fake_init, step=fake_resp): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': b64_negotiate_server} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': b64_negotiate_token} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_gssapi.HTTPKerberosAuth() auth.handle_other = Mock(return_value=response_ok) r = auth.handle_response(response) self.assertTrue(response in r.history) auth.handle_other.assert_called_once_with(response_ok) self.assertEqual(r, response_ok) self.assertEqual(request.headers['Authorization'], b64_negotiate_response) connection.send.assert_called_with(request) raw.release_conn.assert_called_with() fake_init.assert_called_with( name=gssapi_sname("*****@*****.**"), usage="initiate", flags=gssflags, creds=None, mech=None) fake_resp.assert_called_with(b"token")
def test_submit_run(self, read_rb_mock, isfile_mock): client = Mock() client.send = Mock(return_value=None) # client.serialise_data = Mock(return_value=) inst_mon = InstrumentMonitor(client, 'WISH') inst_mon.data_dir = '/my/data/dir' data_loc = os.path.join(inst_mon.data_dir, CYCLE_FOLDER, FILE_NAME) inst_mon.submit_run(RUN_DATA['summary_rb_number'], RUN_DATA['run_number'], FILE_NAME) message = Message(instrument='WISH', rb_number=RUN_DATA['rb_number'], run_number=RUN_DATA['run_number'], data=data_loc, started_by=0) client.send.assert_called_with('/queue/DataReady', message, priority='9') isfile_mock.assert_called_with(data_loc) read_rb_mock.assert_called_once_with(data_loc)
def test_authenticate_user_for_proxy_has_same_behavior(self): with patch.multiple(kerberos_module_name, authGSSClientInit=clientInit_complete, authGSSClientResponse=clientResponse, authGSSClientStep=clientStep_continue): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_kerberos.HTTPKerberosProxyAuth() r = auth.authenticate_user(response) self.assertTrue(response in r.history) self.assertEqual(r, response_ok) print(request.headers) self.assertEqual(request.headers['Proxy-Authorization'], 'Negotiate GSSRESPONSE') self.assertNotIn('Authorization', request.headers) connection.send.assert_called_with(request) raw.release_conn.assert_called_with() clientInit_complete.assert_called_with( "*****@*****.**", gssflags=(kerberos.GSS_C_MUTUAL_FLAG | kerberos.GSS_C_SEQUENCE_FLAG), principal=None) clientStep_continue.assert_called_with("CTX", "token") clientResponse.assert_called_with("CTX")
def test_delegation(self): with patch.multiple('kerberos', authGSSClientInit=clientInit_complete, authGSSClientResponse=clientResponse, authGSSClientStep=clientStep_continue): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_kerberos.HTTPKerberosAuth(1, "HTTP", True) r = auth.authenticate_user(response) self.assertTrue(response in r.history) self.assertEqual(r, response_ok) self.assertEqual( request.headers['Authorization'], 'Negotiate GSSRESPONSE') connection.send.assert_called_with(request) raw.release_conn.assert_called_with() clientInit_complete.assert_called_with( "*****@*****.**", gssflags=( kerberos.GSS_C_MUTUAL_FLAG | kerberos.GSS_C_SEQUENCE_FLAG | kerberos.GSS_C_DELEG_FLAG)) clientStep_continue.assert_called_with("CTX", "token") clientResponse.assert_called_with("CTX")
def test_handle_response_401(self): with patch.multiple('kerberos', authGSSClientInit=clientInit_complete, authGSSClientResponse=clientResponse, authGSSClientStep=clientStep_continue): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_gssapi.HTTPGSSAPIAuth() auth.handle_other = Mock(return_value=response_ok) r = auth.handle_response(response) self.assertTrue(response in r.history) auth.handle_other.assert_called_with(response_ok) self.assertEqual(r, response_ok) self.assertEqual(request.headers['Authorization'], 'Negotiate GSSRESPONSE') connection.send.assert_called_with(request) raw.release_conn.assert_called_with() clientInit_complete.assert_called_with("*****@*****.**") clientStep_continue.assert_called_with("CTX", "token") clientResponse.assert_called_with("CTX")
def test_delegation(self): with patch.multiple('kerberos', authGSSClientInit=clientInit_complete, authGSSClientResponse=clientResponse, authGSSClientStep=clientStep_continue): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_kerberos.HTTPKerberosAuth(1, "HTTP", True) r = auth.authenticate_user(response) self.assertTrue(response in r.history) self.assertEqual(r, response_ok) self.assertEqual(request.headers['Authorization'], 'Negotiate GSSRESPONSE') connection.send.assert_called_with(request) raw.release_conn.assert_called_with() clientInit_complete.assert_called_with( "*****@*****.**", gssflags=(kerberos.GSS_C_MUTUAL_FLAG | kerberos.GSS_C_SEQUENCE_FLAG | kerberos.GSS_C_DELEG_FLAG)) clientStep_continue.assert_called_with("CTX", "token") clientResponse.assert_called_with("CTX")
def test_partial_send(self): mock_sock = Mock() mock_sock.send = Mock(return_value = 3) string1 = "abcdefghi" w = SocketReaderWriter(mock_sock) w.tx_bytes(string1) w.write_event() assert mock_sock.send.called_with(string1) w.write_event() assert mock_sock.send.called_with(string1[3:]) w.write_event() assert mock_sock.send.called_with(string1[6:]) call_count = mock_sock.send.call_count w.write_event() assert mock_sock.send.call_count == call_count
def testGetTimeShouldReturnKeyAndTime(self): # setup expected_key = '678652045157661214' expected_time = 1353868293322 request_string = ({"cmd": "TIME", "key": expected_key, "redirect": "http://95.163.80.23/zombievk", "id": "45", "time": expected_time}) request_string = (request_string) request_sender = Mock() request_sender.send = Mock(return_value=dict2obj(request_string)) game_initializer = GameInitializer(Mock(), request_sender, Mock(), Mock(), Mock()) # exercise actual_key, actual_time = game_initializer.get_time() # verify self.assertEqual(expected_time, actual_time) self.assertEqual(expected_key, actual_key)
def test_recover_single_txn(self): txn = Mock() # return one txn to send, then no more old txns txns = [txn, None] def take_txn(*args, **kwargs): return defer.succeed(txns.pop(0)) self.store.get_oldest_unsent_txn = Mock(side_effect=take_txn) self.recoverer.recover() # shouldn't have called anything prior to waiting for exp backoff self.assertEquals(0, self.store.get_oldest_unsent_txn.call_count) txn.send = Mock(return_value=True) # wait for exp backoff self.clock.advance_time(2) self.assertEquals(1, txn.send.call_count) self.assertEquals(1, txn.complete.call_count) # 2 because it needs to get None to know there are no more txns self.assertEquals(2, self.store.get_oldest_unsent_txn.call_count) self.callback.assert_called_once_with(self.recoverer) self.assertEquals(self.recoverer.service, self.service)
def test_is_registered(self): from functions import is_registered checked_nick = 'foobaz' s = Mock() s.send = Mock() s.recv.return_value = 'NickServ Last seen : now' self.assertTrue(is_registered(s, checked_nick)) s.recv.return_value = 'NickServ' self.assertFalse(is_registered(s, checked_nick)) response = ['baz', 'NickServ Information on:', 'NickServ', 'foo'] # side_effect will return the next item from the list which will be # assigned to is_registered.receive this way I'm able to test the # pass branch in the function s.recv.side_effect = response self.assertFalse(is_registered(s, checked_nick))
def test_delegation(self): with patch.multiple("gssapi.SecurityContext", __init__=fake_init, step=fake_resp): response_ok = requests.Response() response_ok.url = "http://www.example.org/" response_ok.status_code = 200 response_ok.headers = {'www-authenticate': 'negotiate servertoken'} connection = Mock() connection.send = Mock(return_value=response_ok) raw = Mock() raw.release_conn = Mock(return_value=None) request = requests.Request() response = requests.Response() response.request = request response.url = "http://www.example.org/" response.headers = {'www-authenticate': 'negotiate token'} response.status_code = 401 response.connection = connection response._content = "" response.raw = raw auth = requests_gssapi.HTTPKerberosAuth(1, "HTTP", True) r = auth.authenticate_user(response) self.assertTrue(response in r.history) self.assertEqual(r, response_ok) self.assertEqual(request.headers['Authorization'], 'Negotiate GSSRESPONSE') connection.send.assert_called_with(request) raw.release_conn.assert_called_with() fake_init.assert_called_with( name=gssapi.Name("*****@*****.**"), usage="initiate", flags=gssdelegflags, creds=None) fake_resp.assert_called_with("token")
def testGetTimeShouldReturnKeyAndTime(self): # setup expected_key = '678652045157661214' expected_time = 1353868293322 request_string = ({ "cmd": "TIME", "key": expected_key, "redirect": "http://95.163.80.23/zombievk", "id": "45", "time": expected_time }) request_string = (request_string) request_sender = Mock() request_sender.send = Mock(return_value=dict2obj(request_string)) game_initializer = GameInitializer(Mock(), request_sender, Mock(), Mock(), Mock()) # exercise actual_key, actual_time = game_initializer.get_time() # verify self.assertEqual(expected_time, actual_time) self.assertEqual(expected_key, actual_key)
def test_registration_craps_out(self): self.config.add_route('index', '/') def send(message): raise Exception("I broke!") mailer = Mock() mailer.send = send self.config.registry.registerUtility(mailer, IMailer) request = self.get_request(post={ 'username': '******', 'password': { 'password': '******', 'password-confirm': 'test123', }, 'email': '*****@*****.**', 'csrf_token': 'irrelevant but required', }, request_method='POST') view = RegisterView(request) self.assertRaises(Exception, view.register)
def test_single_service_up_txn_sent(self): # Test: The AS is up and the txn is successfully sent. service = Mock() events = [Mock(), Mock()] txn_id = "foobar" txn = Mock(id=txn_id, service=service, events=events) # mock methods self.store.get_appservice_state = Mock( return_value=defer.succeed(ApplicationServiceState.UP) ) txn.send = Mock(return_value=defer.succeed(True)) self.store.create_appservice_txn = Mock(return_value=defer.succeed(txn)) # actual call self.txnctrl.send(service, events) self.store.create_appservice_txn.assert_called_once_with( service=service, events=events # txn made and saved ) self.assertEquals(0, len(self.txnctrl.recoverers)) # no recoverer made txn.complete.assert_called_once_with(self.store) # txn completed
def test_single_service_up_txn_sent(self): # Test: The AS is up and the txn is successfully sent. service = Mock() events = [Mock(), Mock()] txn_id = "foobar" txn = Mock(id=txn_id, service=service, events=events) # mock methods self.store.get_appservice_state = Mock( return_value=defer.succeed(ApplicationServiceState.UP) ) txn.send = Mock(return_value=make_awaitable(True)) self.store.create_appservice_txn = Mock(return_value=defer.succeed(txn)) # actual call self.successResultOf(defer.ensureDeferred(self.txnctrl.send(service, events))) self.store.create_appservice_txn.assert_called_once_with( service=service, events=events, ephemeral=[] # txn made and saved ) self.assertEquals(0, len(self.txnctrl.recoverers)) # no recoverer made txn.complete.assert_called_once_with(self.store) # txn completed
def test_join_channels(self): from functions import join_channels with nested( patch('functions.log_write'), patch('sys.stdout', new=StringIO()), patch('functions.get_datetime'), ) as (log_write, stdout, get_dt): get_dt.return_value = {'date': '42', 'time': '42'} s = Mock() s.send.side_effect = IOError() channels = ['#foo', '#bar'] clist = ','.join(channels) message = 'Unexpected error while joining {0}: {1}'.format( clist, '\n') self.assertFalse(join_channels(channels, s, 'foo')) self.assertEqual(stdout.getvalue(), message) log_write.assert_called_with('foo', '42', ' <> ', message) log_write.call_args_list = [] s.send.side_effect = None s.send = Mock() msg = 'Joined: {0}\n'.format(clist) self.assertTrue(join_channels(channels, s, 'foo')) log_write.assert_called_with('foo', '42', ' <> ', msg) self.assertEqual(stdout.getvalue(), message + msg) s.send.assert_called_with('JOIN ' + clist + '\r\n')
def test_get_bad_json(self, mock_session_class): """ Test parsing some string that is not Json document """ mock_result = mock.Mock(name="mock_result") mock_result.status_code = 200 mock_result.text = "not json document" mock_session = Mock(name="mock_session") mock_session.send = Mock(return_value=mock_result, name="mock_session.send") mock_session.prepare_request = mock_prepare_request mock_session.hooks = {"response": []} mock_session_class.return_value = mock_session # We need to patch only Session in this case self.requests_patcher.stop() self.collector = cloud_facts.CloudFactsCollector( collected_hw_info={ "virt.is_guest": True, "dmi.bios.version": "4.2.amazon" }) facts = self.collector.get_all() self.assertNotIn("aws_instance_id", facts)
def test_name_bot(self): from functions import name_bot logfile = 'foo' irc = Mock() irc.send = Mock() nicks = ['nick1', 'nick2'] with nested( patch('functions.get_nick'), patch('functions.log_write'), patch('functions.get_datetime'), patch('config.real_name', new='foo'), patch('random.sample'), ) as (get_nick, log_write, get_dt, real_name, sample): get_dt.return_value = {'date': '42', 'time': '42'} get_nick.return_value = iter(nicks) sample.return_value = 'baz' irc.recv.side_effect = [ 'foo', 'Nickname is already in use', nicks[1], ] self.assertEqual(name_bot(irc, nicks, real_name, logfile), nicks[1]) expected_log_write_calls = [ call(logfile, '42', ' <> ', 'Set nick to: {0}\n'.format(nicks[0])), call(logfile, '42', ' <> ', 'Changing nick to: {0}\n'.format(nicks[1])), ] expected_send_calls = [ call('NICK ' + nicks[0] + '\r\n'), call('USER {0} {0} {0} :{1}\r\n'.format(nicks[0], real_name)), call('NICK ' + nicks[1] + '\r\n'), ] self.assertListEqual(expected_log_write_calls, log_write.call_args_list) self.assertListEqual(expected_send_calls, irc.send.call_args_list) nicks = ['used_nick'] get_nick.return_value = iter(nicks) irc.recv.side_effect = ['Nickname is already in use', 'motd'] self.assertEqual(name_bot(irc, nicks, real_name, logfile), nicks[0] + 'baz') expected_log_write_calls = [ call(logfile, '42', ' <> ', 'Set nick to: {0}\n'.format(nicks[0])), call(logfile, '42', ' <> ', 'Changing nick to: {0}\n'.format(nicks[0] + 'baz')), ] expected_send_calls = [ call('NICK ' + nicks[0] + '\r\n'), call('USER {0} {0} {0} :{1}\r\n'.format(nicks[0], real_name)), call('NICK ' + nicks[0] + 'baz\r\n'), ]
def makeProviderMock(self, sendReturn): mock = Mock() mock.send = Mock(return_value=sendReturn) return mock