Home | History | Annotate | Download | only in tests 
      1 # Copyright 2014 The Chromium Authors. All rights reserved.
      2 # Use of this source code is governed by a BSD-style license that can be
      3 # found in the LICENSE file.
      4 
      5 import unittest
      6 
      7 # pylint: disable=F0401
      8 import mojo.embedder
      9 from mojo.bindings import messaging
     10 from mojo import system
     11 
     12 
     13 class _ForwardingConnectionErrorHandler(messaging.ConnectionErrorHandler):
     14 
     15   def __init__(self, callback):
     16     self._callback = callback
     17 
     18   def OnError(self, result):
     19     self._callback(result)
     20 
     21 
     22 class ConnectorTest(unittest.TestCase):
     23 
     24   def setUp(self):
     25     mojo.embedder.Init()
     26     self.loop = system.RunLoop()
     27     self.received_messages = []
     28     self.received_errors = []
     29     def _OnMessage(message):
     30       self.received_messages.append(message)
     31       return True
     32     def _OnError(result):
     33       self.received_errors.append(result)
     34     handles = system.MessagePipe()
     35     self.connector = messaging.Connector(handles.handle1)
     36     self.connector.SetIncomingMessageReceiver(
     37         messaging.ForwardingMessageReceiver(_OnMessage))
     38     self.connector.SetErrorHandler(
     39         _ForwardingConnectionErrorHandler(_OnError))
     40     self.connector.Start()
     41     self.handle = handles.handle0
     42 
     43 
     44   def tearDown(self):
     45     self.connector = None
     46     self.handle = None
     47     self.loop = None
     48 
     49   def testConnectorRead(self):
     50     self.handle.WriteMessage()
     51     self.loop.RunUntilIdle()
     52     self.assertTrue(self.received_messages)
     53     self.assertFalse(self.received_errors)
     54 
     55   def testConnectorWrite(self):
     56     self.connector.Accept(messaging.Message())
     57     (result, _, _) = self.handle.ReadMessage()
     58     self.assertEquals(result, system.RESULT_OK)
     59     self.assertFalse(self.received_errors)
     60 
     61   def testConnectorCloseRemoteHandle(self):
     62     self.handle.Close()
     63     self.loop.RunUntilIdle()
     64     self.assertFalse(self.received_messages)
     65     self.assertTrue(self.received_errors)
     66     self.assertEquals(self.received_errors[0],
     67                       system.RESULT_FAILED_PRECONDITION)
     68 
     69   def testConnectorDeleteConnector(self):
     70     self.connector = None
     71     (result, _, _) = self.handle.ReadMessage()
     72     self.assertEquals(result, system.RESULT_FAILED_PRECONDITION)
     73 
     74 
     75 class HeaderTest(unittest.TestCase):
     76 
     77   def testSimpleMessageHeader(self):
     78     header = messaging.MessageHeader(0xdeadbeaf, messaging.NO_FLAG)
     79     self.assertEqual(header.message_type, 0xdeadbeaf)
     80     self.assertFalse(header.has_request_id)
     81     self.assertFalse(header.expects_response)
     82     self.assertFalse(header.is_response)
     83     data = header.Serialize()
     84     other_header = messaging.MessageHeader.Deserialize(data)
     85     self.assertEqual(other_header.message_type, 0xdeadbeaf)
     86     self.assertFalse(other_header.has_request_id)
     87     self.assertFalse(other_header.expects_response)
     88     self.assertFalse(other_header.is_response)
     89 
     90   def testMessageHeaderWithRequestID(self):
     91     # Request message.
     92     header = messaging.MessageHeader(0xdeadbeaf,
     93                                      messaging.MESSAGE_EXPECTS_RESPONSE_FLAG)
     94 
     95     self.assertEqual(header.message_type, 0xdeadbeaf)
     96     self.assertTrue(header.has_request_id)
     97     self.assertTrue(header.expects_response)
     98     self.assertFalse(header.is_response)
     99     self.assertEqual(header.request_id, 0)
    100 
    101     data = header.Serialize()
    102     other_header = messaging.MessageHeader.Deserialize(data)
    103 
    104     self.assertEqual(other_header.message_type, 0xdeadbeaf)
    105     self.assertTrue(other_header.has_request_id)
    106     self.assertTrue(other_header.expects_response)
    107     self.assertFalse(other_header.is_response)
    108     self.assertEqual(other_header.request_id, 0)
    109 
    110     header.request_id = 0xdeadbeafdeadbeaf
    111     data = header.Serialize()
    112     other_header = messaging.MessageHeader.Deserialize(data)
    113 
    114     self.assertEqual(other_header.request_id, 0xdeadbeafdeadbeaf)
    115 
    116     # Response message.
    117     header = messaging.MessageHeader(0xdeadbeaf,
    118                                      messaging.MESSAGE_IS_RESPONSE_FLAG,
    119                                      0xdeadbeafdeadbeaf)
    120 
    121     self.assertEqual(header.message_type, 0xdeadbeaf)
    122     self.assertTrue(header.has_request_id)
    123     self.assertFalse(header.expects_response)
    124     self.assertTrue(header.is_response)
    125     self.assertEqual(header.request_id, 0xdeadbeafdeadbeaf)
    126 
    127     data = header.Serialize()
    128     other_header = messaging.MessageHeader.Deserialize(data)
    129 
    130     self.assertEqual(other_header.message_type, 0xdeadbeaf)
    131     self.assertTrue(other_header.has_request_id)
    132     self.assertFalse(other_header.expects_response)
    133     self.assertTrue(other_header.is_response)
    134     self.assertEqual(other_header.request_id, 0xdeadbeafdeadbeaf)
    135 
    136 
    137 class RouterTest(unittest.TestCase):
    138 
    139   def setUp(self):
    140     mojo.embedder.Init()
    141     self.loop = system.RunLoop()
    142     self.received_messages = []
    143     self.received_errors = []
    144     def _OnMessage(message):
    145       self.received_messages.append(message)
    146       return True
    147     def _OnError(result):
    148       self.received_errors.append(result)
    149     handles = system.MessagePipe()
    150     self.router = messaging.Router(handles.handle1)
    151     self.router.SetIncomingMessageReceiver(
    152         messaging.ForwardingMessageReceiver(_OnMessage))
    153     self.router.SetErrorHandler(
    154         _ForwardingConnectionErrorHandler(_OnError))
    155     self.router.Start()
    156     self.handle = handles.handle0
    157 
    158   def tearDown(self):
    159     self.router = None
    160     self.handle = None
    161     self.loop = None
    162 
    163   def testSimpleMessage(self):
    164     header_data = messaging.MessageHeader(0, messaging.NO_FLAG).Serialize()
    165     message = messaging.Message(header_data)
    166     self.router.Accept(message)
    167     self.loop.RunUntilIdle()
    168     self.assertFalse(self.received_errors)
    169     self.assertFalse(self.received_messages)
    170     (res, data, _) = self.handle.ReadMessage(bytearray(len(header_data)))
    171     self.assertEquals(system.RESULT_OK, res)
    172     self.assertEquals(data[0], header_data)
    173 
    174   def testSimpleReception(self):
    175     header_data = messaging.MessageHeader(0, messaging.NO_FLAG).Serialize()
    176     self.handle.WriteMessage(header_data)
    177     self.loop.RunUntilIdle()
    178     self.assertFalse(self.received_errors)
    179     self.assertEquals(len(self.received_messages), 1)
    180     self.assertEquals(self.received_messages[0].data, header_data)
    181 
    182   def testRequestResponse(self):
    183     header_data = messaging.MessageHeader(
    184         0, messaging.MESSAGE_EXPECTS_RESPONSE_FLAG).Serialize()
    185     message = messaging.Message(header_data)
    186     back_messages = []
    187     def OnBackMessage(message):
    188       back_messages.append(message)
    189     self.router.AcceptWithResponder(message,
    190                                     messaging.ForwardingMessageReceiver(
    191                                         OnBackMessage))
    192     self.loop.RunUntilIdle()
    193     self.assertFalse(self.received_errors)
    194     self.assertFalse(self.received_messages)
    195     (res, data, _) = self.handle.ReadMessage(bytearray(len(header_data)))
    196     self.assertEquals(system.RESULT_OK, res)
    197     message_header = messaging.MessageHeader.Deserialize(data[0])
    198     self.assertNotEquals(message_header.request_id, 0)
    199     response_header_data = messaging.MessageHeader(
    200         0,
    201         messaging.MESSAGE_IS_RESPONSE_FLAG,
    202         message_header.request_id).Serialize()
    203     self.handle.WriteMessage(response_header_data)
    204     self.loop.RunUntilIdle()
    205     self.assertFalse(self.received_errors)
    206     self.assertEquals(len(back_messages), 1)
    207     self.assertEquals(back_messages[0].data, response_header_data)
    208