Пример #1
0
    def test_subscription_good_query(self):
        # Arrange
        app = Mock(ui_methods={}, ui_modules={}, async_db={"tests": None})
        query_request = Mock()
        query_request.arguments = dict(
            query=['{ "name": "test", "ts": { "gte": 145 } }'])
        handler = SubscriptionHandler(app, query_request)

        manager_mock = Mock()

        handler._manager = Mock()
        handler.write_message = Mock(side_effects=ValueError)
        handler._manager = manager_mock

        # Act
        handler.open(resource_type="test")

        # Assert
        self.assertTrue(manager_mock.createChannel.called)
        self.assertEqual(manager_mock.createChannel.call_args[0][0], {
            "name": "test",
            "ts": {
                "gte": 145
            }
        })
Пример #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 known_operator_arguments(self):
     operators = Mock()
     operators.arguments = dict(
         oper1=('1a', '1b'),
         oper2=('2a', ),
         oper3=('3a', '3b'),
     )
     return operators
Пример #4
0
 def known_operator_arguments(self):
     operators = Mock()
     operators.arguments = dict(
         oper1=('1a', '1b'),
         oper2=('2a',),
         oper3=('3a', '3b'),
     )
     return operators
Пример #5
0
    def test_baseline_2axes(self):
        fig = self.app.figure_data[self.fignum].figure
        fig.add_subplot(212, sharex=fig.add_subplot(211))

        req = Mock(cookies=dict())
        req.arguments = dict(fignum=[str(self.fignum)],
                             blr_method=['median'],
                             blr_window_=['3'])
        BaselineHandler(self.app, req).post()
    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_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_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_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_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')
Пример #11
0
    def test_resource_id_subscription(self):
        # Arrange
        app = Mock(ui_methods = {}, ui_modules = {}, async_db = {"tests": None})
        resource_mock = Mock()
        resource_mock.arguments = dict()
        handler = SubscriptionHandler(app, resource_mock)
        handler._manager = Mock()
        
        # Act
        handler.open(resource_type = "test", resource_id="1")

        # Assert
        self.assertEqual(handler._manager.createChannel.call_args[0][0], { "id": "1" })
Пример #12
0
    def test_resource_id_subscription(self):
        # Arrange
        app = Mock(ui_methods={}, ui_modules={}, async_db={"tests": None})
        resource_mock = Mock()
        resource_mock.arguments = dict()
        handler = SubscriptionHandler(app, resource_mock)
        handler._manager = Mock()

        # Act
        handler.open(resource_type="test", resource_id="1")

        # Assert
        self.assertEqual(handler._manager.createChannel.call_args[0][0],
                         {"id": "1"})
    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')
Пример #14
0
    def test_resource_subscription(self, listen_mock):
        # Arrange
        app = Mock(ui_methods = {}, ui_modules = {}, async_db = {"tests": None})
        resource_mock = Mock()
        resource_mock.arguments = dict()
        handler = SubscriptionHandler(app, resource_mock)
        handler._manager = Mock()

        # Act
        handler.open(resource_type = "test")

        # Assert
        self.assertTrue(listen_mock.called)
        self.assertEqual(handler._manager.createChannel.call_count, 1)
        self.assertEqual(handler._manager.createChannel.call_args[0][1], "test")
    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_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, {})
Пример #17
0
 def test_subscription_good_fields(self):
     # Arrange
     app = Mock(ui_methods = {}, ui_modules = {}, async_db = {"tests": None})
     fields_request = Mock()
     fields_request.arguments = dict(fields = ["name,ts"])
     
     manager_mock = Mock()
     
     handler = SubscriptionHandler(app, fields_request)
     handler._manager = manager_mock
     
     # Act
     handler.open(resource_type = "test")
     
     # Assert
     self.assertEqual(manager_mock.createChannel.call_args[0][2], ["name", "ts"])
Пример #18
0
    def test_resource_subscription(self, listen_mock):
        # Arrange
        app = Mock(ui_methods={}, ui_modules={}, async_db={"tests": None})
        resource_mock = Mock()
        resource_mock.arguments = dict()
        handler = SubscriptionHandler(app, resource_mock)
        handler._manager = Mock()

        # Act
        handler.open(resource_type="test")

        # Assert
        self.assertTrue(listen_mock.called)
        self.assertEqual(handler._manager.createChannel.call_count, 1)
        self.assertEqual(handler._manager.createChannel.call_args[0][1],
                         "test")
Пример #19
0
    def test_subscription_good_fields(self):
        # Arrange
        app = Mock(ui_methods={}, ui_modules={}, async_db={"tests": None})
        fields_request = Mock()
        fields_request.arguments = dict(fields=["name,ts"])

        manager_mock = Mock()

        handler = SubscriptionHandler(app, fields_request)
        handler._manager = manager_mock

        # Act
        handler.open(resource_type="test")

        # Assert
        self.assertEqual(manager_mock.createChannel.call_args[0][2],
                         ["name", "ts"])
Пример #20
0
    def test_subscription_bad_query(self):
        # Arrange
        app = Mock(ui_methods = {}, ui_modules = {}, async_db = { "tests": None})
        query_request = Mock()
        query_request.arguments = dict(query = ["{ name: 'test', ts: { gte: 145 }"])

        manager_mock = Mock()
        
        handler = SubscriptionHandler(app, query_request)
        handler._manager = manager_mock
        handler.write_message = Mock(side_effects = ValueError)
        
        # Act
        handler.open(resource_type = "test")

        # Assert
        self.assertFalse(handler.client)
        self.assertFalse(manager_mock.createChannel.called)
Пример #21
0
    def test_subscription_bad_query(self):
        # Arrange
        app = Mock(ui_methods={}, ui_modules={}, async_db={"tests": None})
        query_request = Mock()
        query_request.arguments = dict(
            query=["{ name: 'test', ts: { gte: 145 }"])

        manager_mock = Mock()

        handler = SubscriptionHandler(app, query_request)
        handler._manager = manager_mock
        handler.write_message = Mock(side_effects=ValueError)

        # Act
        handler.open(resource_type="test")

        # Assert
        self.assertFalse(handler.client)
        self.assertFalse(manager_mock.createChannel.called)
Пример #22
0
    def test_select(self):
        fignum = self.app.register_new_figure((1, 1))
        req = Mock(cookies=dict())
        req.arguments = dict(fignum=[str(fignum)],
                             ds_name=['Test Set'],
                             ds_kind=['Raman'],
                             name=['a'])
        h = SelectHandler(self.app, req)
        h.write = Mock()
        h.post()
        self.assertEqual(len(h.write.call_args_list), 1)
        args, kwargs = h.write.call_args
        self.assertRegex(args[0], '\[-?\d+.\d+, \d+.\d+, \d+.\d+, \d+.\d+]')
        self.assertEqual(kwargs, {})

        fig_data = self.app.figure_data[fignum]
        self.assertEqual(fig_data.title, 'a')
        x = fig_data.get_trajectory('upload')
        assert_array_equal(x, np.arange(12).reshape((6, 2)))
Пример #23
0
 def test_subscription_good_query(self):
     # Arrange
     app = Mock(ui_methods = {}, ui_modules = {}, async_db = {"tests": None})
     query_request = Mock()
     query_request.arguments = dict(query = ['{ "name": "test", "ts": { "gte": 145 } }'])
     handler = SubscriptionHandler(app, query_request)
     
     manager_mock = Mock()
     
     handler._manager = Mock()
     handler.write_message = Mock(side_effects = ValueError)
     handler._manager = manager_mock
     
     # Act
     handler.open(resource_type = "test")
     
     # Assert
     self.assertTrue(manager_mock.createChannel.called)
     self.assertEqual(manager_mock.createChannel.call_args[0][0], { "name": "test", "ts": { "gte": 145 } })
Пример #24
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)
Пример #25
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!")
Пример #26
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)
Пример #27
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)
Пример #28
0
 def test_get_version_will_fallback_to_query_params(self):
     request = Mock()
     request.headers = {"Accept": "text/html"}
     request.arguments = {'v': [1]}
     self.assertEqual(1, AcceptsVersionNegotiator().get_version(request))
Пример #29
0
 def test_baseline_1axis(self):
     req = Mock(cookies=dict())
     req.arguments = dict(fignum=[str(self.fignum)], blr_method=['polyfit'])
     BaselineHandler(self.app, req).post()
 def test_get_version_will_fallback_to_query_params(self):
     request = Mock()
     request.headers = {"Accept": "text/html"}
     request.arguments = {'v': [1]}
     self.assertEqual(1, AcceptsVersionNegotiator().get_version(request))