示例#1
0
    def test_should_initialize_logging_when_service_starts(self):
        mock_receiver = Mock(Receiver)

        Receiver.startService(mock_receiver)

        self.assertEquals(
            call(), mock_receiver.initialize_twisted_logging.call_args)
示例#2
0
    def test_should_create_process_protocol_with_tracking_id_if_given(self, mock_protocol, mock_reactor):
        mock_protocol.return_value = 'mock-protocol'
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_receiver.states = {'foo': Mock()}
        mock_receiver.broadcaster = mock_broadcaster
        mock_receiver.get_target_directory.return_value = '/etc/yadtshell/targets/devabc123'

        mock_receiver.configuration = {'hostname': 'hostname',
                                       'python_command': '/usr/bin/python',
                                       'script_to_execute': '/usr/bin/yadtshell'}

        mock_event = Mock(Event)
        mock_event.target = 'devabc123'
        mock_event.command = 'yadtshell'
        mock_event.arguments = ['update', '--tracking-id=foo']

        Receiver.perform_request(mock_receiver, mock_event, Mock())

        expected_command_with_arguments = '/usr/bin/python /usr/bin/yadtshell update --tracking-id=foo'

        self.assertEqual(
            call(
                'hostname', mock_broadcaster, 'devabc123', expected_command_with_arguments,
                tracking_id='foo'), mock_protocol.call_args)
示例#3
0
    def test_should_set_configuration(self):
        configuration = 'configuration'
        receiver = Receiver()

        receiver.set_configuration(configuration)

        self.assertEquals(configuration, receiver.configuration)
示例#4
0
    def test_should_queue_call_to_refresh_connection(self, mock_reactor):
        mock_receiver = Mock(Receiver)
        mock_receiver.broadcaster = Mock()

        Receiver._refresh_connection(mock_receiver, 123)

        self.assertEquals(
            call(123, mock_receiver._refresh_connection), mock_reactor.callLater.call_args)
示例#5
0
    def test_should_not_close_connection_to_broadcaster_when_first_call(self, mock_reactor):
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_receiver.broadcaster = mock_broadcaster

        Receiver._refresh_connection(mock_receiver, 123, first_call=True)

        self.assertEquals(None, mock_broadcaster.client.sendClose.call_args)
示例#6
0
    def test_should_log_shutting_down_of_service(self, mock_log):
        mock_receiver = Mock(Receiver)

        Receiver.stopService(mock_receiver)

        # Since all the method does is logging we are asserting it here.
        self.assertEquals(
            call('shutting down service'), mock_log.msg.call_args)
示例#7
0
    def test_should_set_the_client_to_none(self, mock_log):
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_broadcaster.client = 'Test client'
        mock_receiver.broadcaster = mock_broadcaster

        Receiver.onConnectionLost(mock_receiver, 'Spam eggs.')

        self.assertEquals(None, mock_broadcaster.client)
示例#8
0
    def test_should_raise_exception_when_target_directory_does_not_exist(self, mock_exists):
        mock_exists.return_value = False
        receiver = Receiver()
        configuration = {'hostname': 'hostname',
                         'targets_directory': '/etc/yadtshell/targets/'}
        receiver.set_configuration(configuration)

        self.assertRaises(
            ReceiverException, receiver.get_target_directory, 'spargel')
    def test_should_announce_showdown(self, call_later):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']

        Receiver.handle_request(receiver, event)

        call_later.assert_called_with(10, receiver.states['foo'].showdown)
    def test_should_initialize_fsm_when_handling_request(self, uuid_fun):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        Receiver.handle_request(receiver, event)

        request_fsm = receiver.states['foo']
        self.assertEqual(request_fsm.current, 'negotiating')
    def test_should_call_when_lower_vote_received(self):
        receiver = Mock(Receiver)
        fsm = Mock()
        fsm.vote = 42
        receiver.states = {'id123': fsm}
        lower_vote_event = {'id': 'vote', 'tracking_id': 'id123', 'payload': 5}

        Receiver.onEvent(receiver, 'target', lower_vote_event)

        fsm.call.assert_called_with()
    def test_should_announce_showdown(self, call_later):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']

        Receiver.handle_request(receiver, event)

        call_later.assert_called_with(10, receiver.states['foo'].showdown)
    def test_should_initialize_fsm_when_handling_request(self, uuid_fun):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        Receiver.handle_request(receiver, event)

        request_fsm = receiver.states['foo']
        self.assertEqual(request_fsm.current, 'negotiating')
示例#14
0
    def test_should_join_target_name_with_targets_directory(self, mock_exists):
        mock_exists.return_value = True
        receiver = Receiver()
        configuration = {'hostname': 'hostname',
                         'targets_directory': '/etc/yadtshell/targets/'}
        receiver.set_configuration(configuration)

        actual_target_directory = receiver.get_target_directory('spargel')

        self.assertEquals(
            '/etc/yadtshell/targets/spargel', actual_target_directory)
    def test_should_vote_when_handling_request(self, uuid_fun):
        uuid_fun.return_value = "1234-5678"
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        event.target = 'target'
        Receiver.handle_request(receiver, event)

        receiver.broadcaster._sendEvent.assert_called_with(
            'vote', data='1234-5678', tracking_id='foo', target='target')
    def test_should_fold_when_higher_vote_received(self):
        receiver = Mock(Receiver)
        fsm = Mock()
        fsm.vote = 5
        receiver.states = {'id123': fsm}
        higher_vote_event = {'id': 'vote',
                             'tracking_id': 'id123',
                             'payload': 42
                             }

        Receiver.onEvent(receiver, 'target', higher_vote_event)

        fsm.fold.assert_called_with()
    def test_should_call_when_lower_vote_received(self):
        receiver = Mock(Receiver)
        fsm = Mock()
        fsm.vote = 42
        receiver.states = {'id123': fsm}
        lower_vote_event = {'id': 'vote',
                            'tracking_id': 'id123',
                            'payload': 5
                            }

        Receiver.onEvent(receiver, 'target', lower_vote_event)

        fsm.call.assert_called_with()
    def test_write_metrics_to_file(self, path_, open_):
        # initialize a receiver with given configuration
        configuration = {'metrics_directory': '/tmp/metrics',
                         'metrics_file': '/tmp/metrics/yrc.metrics'
                         }

        yrc = Receiver()
        yrc.set_configuration(configuration)
        open_.return_value = MagicMock(spec=file)
        path_.return_value = True
        yrc.write_metrics_to_file()
        open_.assert_called_once_with('/tmp/metrics/yrc.metrics', 'w')
        file_handle = open_.return_value.__enter__.return_value
        file_handle.write.assert_called_once_with('foo=42\n')
    def test_should_vote_when_handling_request(self, uuid_fun):
        uuid_fun.return_value = "1234-5678"
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        event.target = 'target'
        Receiver.handle_request(receiver, event)

        receiver.broadcaster._sendEvent.assert_called_with('vote',
                                                           data='1234-5678',
                                                           tracking_id='foo',
                                                           target='target')
示例#20
0
    def test_should_handle_request(self, mock_event_class):
        mock_receiver = Mock(Receiver)
        mock_receiver.states = {None: Mock()}
        mock_event = Mock(Event)
        mock_event.is_a_vote = False
        mock_event_class.return_value = mock_event

        Receiver.onEvent(mock_receiver, 'target', {
                         'id': 'request', 'cmd': 'command', 'args': 'args'})

        self.assertEqual(
            call('target', {'id': 'request', 'cmd': 'command', 'args': 'args'}), mock_event_class.call_args)
        self.assertEqual(
            call(mock_event), mock_receiver.handle_request.call_args)
    def test_should_fold_when_higher_vote_received(self):
        receiver = Mock(Receiver)
        fsm = Mock()
        fsm.vote = 5
        receiver.states = {'id123': fsm}
        higher_vote_event = {
            'id': 'vote',
            'tracking_id': 'id123',
            'payload': 42
        }

        Receiver.onEvent(receiver, 'target', higher_vote_event)

        fsm.fold.assert_called_with()
    def test_should_cleanup_fsm_after_finishing(self):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        Receiver.handle_request(receiver, event)

        receiver.states['foo'].showdown()
        receiver.states['foo'].spawned()

        self.assertEqual(receiver.states, {})
    def test_should_call_start_logging_when_initializing_twisted_logging(self, mock_log, mock_log_file_class):
        receiver = Receiver()
        receiver.set_configuration({'log_filename': 'log/file.log',
                                    'targets': set(['devabc123']),
                                    'broadcaster_host': 'broadcaster_host',
                                    'broadcaster_port': 1234})
        mock_log_file = Mock(LogFile)
        mock_log_file_class.fromFullPath.return_value = mock_log_file

        receiver.initialize_twisted_logging()

        self.assertEqual(
            call('log/file.log', rotateLength=20000000, maxRotatedFiles=10),
            mock_log_file_class.fromFullPath.call_args)
        self.assertEquals(call(mock_log_file), mock_log.startLogging.call_args)
    def test_should_cleanup_fsm_after_finishing(self):
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.states = {'foo': None}
        event = Mock()
        event.arguments = ['--tracking-id=foo']
        Receiver.handle_request(receiver, event)

        receiver.states['foo'].showdown()
        receiver.states['foo'].spawned()

        self.assertEqual(receiver.states, {})
示例#25
0
    def test_subscribe_target_is_allowed(self):
        mock_receiver = Mock(Receiver)
        mock_config = Mock(ReceiverConfig)
        mock_config.configuration = {'allowed_targets': ['foo']}
        mock_config.__getitem__ = lambda _self, key: mock_config.configuration[
            key]
        mock_receiver.broadcaster = Mock()
        mock_receiver.broadcaster.client = Mock()
        mock_receiver.configuration = mock_config

        Receiver.subscribeTarget(mock_receiver, 'foo')

        mock_receiver.configuration.reload_targets.assert_called_with()
        mock_receiver.broadcaster.client.subscribe.assert_called_with(
            mock_receiver.onEvent, 'foo')
示例#26
0
    def test_should_not_refresh_when_no_broadcaster_but_hour_is_2_am(self, datetime):
        time = Mock()
        datetime.now.return_value = time
        time.hour = 2
        receiver = Mock(Receiver)

        self.assertFalse(Receiver._should_refresh_connection(receiver))
示例#27
0
    def test_should_publish_event_about_failed_request_when_handle_request_fails(self, mock_log, mock_event_class):
        mock_receiver = Mock(Receiver)
        mock_receiver.handle_request.side_effect = ReceiverException(
            'It failed!')
        mock_receiver.states = {'some-id': Mock()}
        mock_event = Mock(Event)
        mock_event.is_a_vote = False
        mock_event.tracking_id = 'some-id'
        mock_event_class.return_value = mock_event

        Receiver.onEvent(mock_receiver, 'target', {
                         'id': 'request', 'cmd': 'command', 'args': 'args'})

        self.assertEqual(
            call('target', {'id': 'request', 'cmd': 'command', 'args': 'args'}), mock_event_class.call_args)
        self.assertEqual(
            call(mock_event, 'It failed!'), mock_receiver.publish_failed.call_args)
示例#28
0
    def test_should_refresh_when_connected_and_hour_is_2_am(self, datetime):
        time = Mock()
        datetime.now.return_value = time
        time.hour = 2
        receiver = Mock(Receiver)
        receiver.broadcaster = Mock()
        receiver.broadcaster.client = Mock()

        self.assertTrue(Receiver._should_refresh_connection(receiver))
示例#29
0
    def test_should_publish_event_about_failed_command_on_target(self, mock_log):
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_receiver.broadcaster = mock_broadcaster

        mock_event = Mock(Event)
        mock_event.target = 'devabc123'
        mock_event.tracking_id = 'any-tracking-id'
        mock_event.command = 'yadtshell'
        mock_event.arguments = ['update']

        Receiver.publish_failed(mock_receiver, mock_event, 'It failed!')

        mock_broadcaster.publish_cmd_for_target.assert_called_with(
            'devabc123',
            'yadtshell',
            'failed',
            'It failed!',
            tracking_id='any-tracking-id')
        self.assertEqual(yadtreceiver.METRICS['commands_failed.devabc123'], 1)
示例#30
0
    def test_should_broadcast_error_when_spawning_fails(self, mock_protocol, mock_reactor):
        mock_protocol.side_effect = RuntimeError('Booom!')
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_receiver.broadcaster = mock_broadcaster
        mock_receiver.get_target_directory.return_value = '/etc/yadtshell/targets/devabc123'
        mock_receiver.states = {None: Mock()}

        mock_receiver.configuration = {'hostname': 'hostname',
                                       'python_command': '/usr/bin/python',
                                       'script_to_execute': '/usr/bin/yadtshell'}

        mock_event = Mock(Event)
        mock_event.target = 'devabc123'
        mock_event.command = 'yadtshell'
        mock_event.arguments = ['update']

        Receiver.perform_request(mock_receiver, mock_event, Mock())

        mock_receiver.publish_failed.assert_called_with(mock_event, "<type 'exceptions.RuntimeError'> : Booom!")
示例#31
0
    def test_should_publish_event_about_started_command_on_target(self, mock_log):
        mock_receiver = Mock(Receiver)
        mock_receiver.configuration = {'hostname': 'hostname'}
        mock_broadcaster = Mock()
        mock_receiver.broadcaster = mock_broadcaster

        mock_event = Mock(Event)
        mock_event.tracking_id = 'any-tracking-id'
        mock_event.target = 'devabc123'
        mock_event.command = 'yadtshell'
        mock_event.arguments = ['update']

        Receiver.publish_start(mock_receiver, mock_event)

        mock_broadcaster.publish_cmd_for_target.assert_called_with(
            'devabc123',
            'yadtshell',
            'started',
            '(hostname) target[devabc123] request: command="yadtshell", arguments=[\'update\']',
            tracking_id='any-tracking-id')
        self.assertEqual(yadtreceiver.METRICS['commands_started.devabc123'], 1)
示例#32
0
    def test_should_exit_when_no_target_configured(self, mock_exit, mock_log):
        receiver = Receiver()
        configuration = ConfigurationDict(allowed_targets=set(),
                                          broadcaster_host='broadcaster_host',
                                          broadcaster_port=1234)
        receiver.set_configuration(configuration)
        mock_broadcaster_client = Mock()
        receiver.broadcaster = mock_broadcaster_client

        receiver.onConnect()

        self.assertEquals(call(1), mock_exit.call_args)
示例#33
0
    def test_should_spawn_new_process_on_reactor_even_when_not_registered(self, _, mock_protocol, mock_reactor):
        mock_protocol.return_value = 'mock-protocol'
        mock_receiver = Mock(Receiver)
        mock_broadcaster = Mock()
        mock_receiver.broadcaster = mock_broadcaster
        mock_receiver.get_target_directory.return_value = '/etc/yadtshell/targets/devabc123'
        mock_receiver.states = {}

        mock_receiver.configuration = {'hostname': 'hostname',
                                       'python_command': '/usr/bin/python',
                                       'script_to_execute': '/usr/bin/yadtshell'}

        mock_event = Mock(Event)
        mock_event.target = 'devabc123'
        mock_event.command = 'yadtshell'
        mock_event.arguments = ['update']

        Receiver.perform_request(mock_receiver, mock_event, Mock())

        self.assertEquals(call('hostname', mock_broadcaster, 'devabc123',
                               '/usr/bin/python /usr/bin/yadtshell update', tracking_id=None), mock_protocol.call_args)
        self.assertEquals(call('mock-protocol', '/usr/bin/python', [
                          '/usr/bin/python', '/usr/bin/yadtshell', 'update'], path='/etc/yadtshell/targets/devabc123', env={}), mock_reactor.spawnProcess.call_args)
示例#34
0
    def test_should_subscribe_to_target_from_configuration_when_connected(self):
        receiver = Receiver()
        mock_broadcaster_client = Mock()
        receiver.broadcaster = mock_broadcaster_client
        configuration = ConfigurationDict(allowed_targets=set(['devabc123']),
                                          broadcaster_host='broadcaster_host',
                                          broadcaster_port=1234)
        receiver.set_configuration(configuration)

        receiver.onConnect()

        self.assertEquals(call(receiver.onEvent, 'devabc123'),
                          mock_broadcaster_client.client.subscribe.call_args)
示例#35
0
    def test_should_initialize_broadcaster_when_connecting_broadcaster(self, mock_wamb):
        configuration = {'broadcaster_host': 'broadcaster-host',
                         'broadcaster_port': 1234}
        receiver = Receiver()
        receiver.set_configuration(configuration)

        receiver._connect_broadcaster()

        self.assertEquals(
            call('broadcaster-host', 1234, 'yadtreceiver'), mock_wamb.call_args)
示例#36
0
 def test_write_metrics_to_file_is_noop_with_no_metrics_directory(self,
                                                                  path_, open_):
     configuration = {'metrics_directory': None,
                      'metrics_file': None,
                      }
     yrc = Receiver()
     yrc.set_configuration(configuration)
     yrc.write_metrics_to_file()
     self.assertFalse(open_.called)
     self.assertFalse(path_.called)
示例#37
0
    def test_should_add_session_handler_to_broadcaster_when_connecting_broadcaster(self, mock_wamb):
        receiver = Receiver()
        configuration = {'broadcaster_host': 'broadcasterhost',
                         'broadcaster_port': 1234}
        receiver.set_configuration(configuration)
        mock_broadcaster_client = Mock()
        mock_wamb.return_value = mock_broadcaster_client

        receiver._connect_broadcaster()

        self.assertEquals(
            call(receiver.onConnect), mock_broadcaster_client.addOnSessionOpenHandler.call_args)
示例#38
0
    def test_should_subscribe_to_targets_from_configuration_in_alphabetical_order_when_connected(self):
        receiver = Receiver()
        mock_broadcaster_client = Mock()
        receiver.broadcaster = mock_broadcaster_client
        configuration = ConfigurationDict(allowed_targets=set(['dev01', 'dev02', 'dev03']),
                                          broadcaster_host='broadcaster_host',
                                          broadcaster_port=1234)
        receiver.set_configuration(configuration)

        receiver.onConnect()

        self.assertEquals(
            [call(receiver.onEvent, 'dev01'),
             call(receiver.onEvent, 'dev02'),
             call(receiver.onEvent, 'dev03')],
            mock_broadcaster_client.client.subscribe.call_args_list)