Пример #1
0
    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)
Пример #2
0
    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)
Пример #4
0
    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)
Пример #5
0
    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)
Пример #6
0
    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)
Пример #7
0
    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
Пример #8
0
    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
Пример #9
0
    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)
Пример #10
0
    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)
Пример #13
0
    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)
Пример #18
0
 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))
Пример #19
0
 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))
Пример #20
0
    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
        )
Пример #21
0
    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')
Пример #22
0
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
Пример #23
0
    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')
Пример #24
0
    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_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-----")
Пример #26
0
    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
        )
Пример #27
0
    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")
Пример #30
0
    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")
Пример #31
0
    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")
Пример #32
0
    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")
Пример #34
0
    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")
Пример #35
0
    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")
Пример #37
0
    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
Пример #38
0
    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")
Пример #39
0
    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)
Пример #40
0
    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)
Пример #41
0
    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)
Пример #42
0
    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))
Пример #43
0
    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")
Пример #44
0
    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)
Пример #45
0
    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)
Пример #46
0
    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
Пример #47
0
    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
Пример #48
0
    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)
Пример #50
0
    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'),
            ]
Пример #51
0
 def makeProviderMock(self, sendReturn):
   mock = Mock()
   mock.send = Mock(return_value=sendReturn)
   return mock