def test_transmit(self):
packet = {'a': 'b'}
value = 11
que = HMQueue()
que._queue.put = Mock()
que.transmit(packet)
que._queue.put.assert_called_once_with((que.MID_PRIORITY, packet))
def test_transmit( self ):
packet = {'a': 'b'}
value = 11
que = HMQueue()
que._queue.put = Mock()
que.transmit( packet )
que._queue.put.assert_called_once_with( ( que.MID_PRIORITY, packet ) )
def test_receive(self):
packet = {'a': 'b'}
value = 11
que = HMQueue()
priority = que.MID_PRIORITY
que._queue.get = Mock(return_value=(priority, value))
ret = que.receive()
que._queue.get.assert_called_once_with()
self.assertEqual(value, ret)
def test_receive( self ):
packet = {'a': 'b'}
value = 11
que = HMQueue()
priority = que.MID_PRIORITY
que._queue.get = Mock( return_value=( priority, value ) )
ret = que.receive()
que._queue.get.assert_called_once_with()
self.assertEqual( value, ret )
def test_ZigBeeOutput_throws_exception(self, zo, t):
queue = HMQueue()
thread = ZigBeeOutputThread(queue, 1)
zo.side_effect = KeyError('boom')
thread.zigbeeConnect()
self.assertFalse(thread.connected)
self.assertFalse(thread.talking)
def test_run(self):
queue = HMQueue()
packet = 555
thread = ZigBeeOutputThread(queue, 1)
thread.connectAndProcessZigBeeCommands = MagicMock()
thread.run()
thread.connectAndProcessZigBeeCommands.assert_called_once_with()
def test_ProcessInput_work_status_request(self, process, config, receive):
envelope = DataEnvelope(Constants.EnvelopeTypes.STATUS)
que = HMQueue()
pi = ProcessInput(que)
que.receive.return_value = envelope
pi.work()
que.receive.assert_called_oncy_with()
pi.commands[envelope.type].process.assert_called_once_with(envelope)
def __init__(self):
super(Main, self).__init__()
self.logger.debug('Start Input Queue')
input_queue = HMQueue(name="ZigBeeInput")
self.logger.debug('instantuate XBeeInputThread')
xbee_thread = XBeeInputThread(input_queue)
self.logger.debug('Start Thread')
xbee_thread.start()
def test_processCommandToZigBee_with_IOError_in_SendCommand(self):
queue = HMQueue()
packet = 555
thread = ZigBeeOutputThread(queue, 1)
thread.output_queue = MagicMock()
thread.output_queue.receive = MagicMock()
thread.connected = True
thread.talking = True
thread.done = False
thread.zigbee_output = MagicMock()
thread.zigbee_output.sendCommand = MagicMock(side_effect=IOError())
thread.processCommandToZigBee()
self.assertFalse(thread.connected)
self.assertFalse(thread.talking)
self.assertFalse(thread.done)
def test_processCconnectAndProcessZigBeeCommands(self):
queue = HMQueue()
packet = 555
thread = ZigBeeOutputThread(queue, 1)
thread.connected = False
thread.talking = True
thread.done = False
thread.zigbeeConnect = MagicMock(return_value=True)
thread.processCommandToZigBee = MagicMock(
side_effect=KeyboardInterrupt)
thread.connectAndProcessZigBeeCommands()
thread.zigbeeConnect.assert_called_once_with()
thread.zigbeeConnect.assert_called_once_with()
self.assertTrue(thread.connected)
self.assertTrue(thread.talking)
self.assertFalse(thread.done)
def test_processCommandToZigBee(self, qr):
packet = {}
queue = HMQueue()
value = 555
data = {}
packet['value'] = value
packet['data'] = data
packet['id'] = 0xab
thread = ZigBeeOutputThread(queue, 1)
qr.return_value = packet
thread.zigbee_output = MagicMock()
thread.zigbee_output.sendCommand = MagicMock()
thread.connected = True
thread.talking = True
thread.done = False
thread.processCommandToZigBee()
thread.zigbee_output.sendCommand.assert_called_once_with(**packet)
self.assertTrue(thread.connected)
self.assertTrue(thread.talking)
thread.done = False
def startCOSM(self, options):
'''
Start the COSM processing.
>>> from optparse import OptionParser
>>> from outputs.cosm.control import COSMControl
>>> c = COSMControl() # doctest: +SKIP
>>> options = 1 # doctest: +SKIP
>>> c.startCOSM(options) # doctest: +SKIP
>>> c.cosmOutputThread.forever = False # doctest: +SKIP
>>> c = None # doctest: +SKIP
.. warning:: This doctest has been disabled. It is trying to start too much.
'''
self.logger.debug('COSM starting up')
self.queue = HMQueue('COSM')
self.cosmOutputThread = COSMOutputThread(self.queue,
options,
name='COSM')
self.cosmOutputThread.start()
self.cosm = COSMOutputStep(self.queue)
def startZigBee(self, in_test_mode):
'''
Start the ZigBee processing.
This consists of three parts:
#. Start the ZigBeeQueue which used Queue, a thread safe queue for communcating
between threads.
#. Start the ZigBeeOutputThread which talks to the ZigBee server. This is a slow process.
#. Start the ZigBeeOutputProcessing object which takes massages sent to ZigBee on the
main thread and sends them to the ZigBee thread.
'''
self.queue = HMQueue('ZigBeeInput')
self.in_test_mode = in_test_mode
self.zig = ZigBeeOutputStep(self.queue)
self.ZigBeeOutputThread = ZigBeeOutputThread(self.queue,
self.in_test_mode)
self.ZigBeeOutputThread.start()
def run(self):
self.logger.debug('Setting up global_data')
global_data = {}
global_data[Constants.GlobalData.CURRENT_VALUES] = CurrentValues()
global_data[Constants.GlobalData.OPTIONS] = self.options
global_data[Constants.GlobalData.ARGS] = self.args
global_data[Constants.GlobalData.START_TIME] = datetime.utcnow()
global_data[Constants.GlobalData.INPUT_QUEUE] = HMQueue("Input")
self.module_loader = ModuleLoader()
self.module_loader.load(global_data)
self.startOutputs(global_data)
self.startInputs(global_data)
self.pubAid = PubSubAid()
# Endless loop will never return
self.input.input()
self.logger.debug("Exiting")
def test_topic_name( self ):
queue = HMQueue()
zig = ZigBeeOutputStep( queue )
self.assertEqual( Constants.TopicNames.ZigBeeOutput, zig.topic_name )
def test_logger_name( self ):
queue = HMQueue()
zig = ZigBeeOutputStep( queue )
self.assertEqual( Constants.LogKeys.outputsZigBee, zig.logger_name )
def test_input(self, receive, work, config):
que = HMQueue()
self.pi = ProcessInput(que)
work.side_effect = self.side_effect
self.pi.input()
self.pi.work.assert_called_once_with()
def test_clear( self ):
que = HMQueue()
que._queue.get = Mock( side_effect=Queue.Empty )
que.clear()
que._queue.get.assert_called_once_with( False )
def test_logger_name( self , config ):
queue = HMQueue( 'COSM' )
options = 'a'
thread = COSMOutputThread( options, queue )
self.assertEqual( thread.logger_name, Constants.LogKeys.outputsCOSM )
def test_clear(self):
que = HMQueue()
que._queue.get = Mock(side_effect=Queue.Empty)
que.clear()
que._queue.get.assert_called_once_with(False)
def test_logger_name(self):
queue = HMQueue()
thread = ZigBeeOutputThread(queue, 1)
self.assertEqual(thread.logger_name, Constants.LogKeys.outputsZigBee)
def test_logger_name(self):
que = HMQueue()
self.assertEqual(que.logger_name, Constants.LogKeys.lib)
