class Root(controllers.Root):
# Class attributes overridden by instance value in start() method
# (tested by stop() method below.)
despatch = None
discover = None
def start(self):
# Load and start the event dispatcher,
# and associated logic that performs WebBrick discovery
self.eventloader = EventRouterLoader()
# system files first.
self.eventloader.loadHandlers( despatchConfig )
if self.eventloader:
self.eventloader.start()
# now disovery handler.
self.discover = Discovery.DiscoverHandler()
self.discover.start(self.eventloader.getEventRouter())
# wbtst = WebBrick.WebBrickTest()
# Assignments to the controller instance (or class) are used to define handing
# of URIs. See cherrypy_cputil.get_object_trail() for some of the details.
# (TODO: consider how this is affected by local instance attributes like
# 'despatch' and 'discover' above.)
if 0:
# Local testing
self.wbcnf = MockWbConfig.MockWebBrickCfgEdit()
else:
# Production / live WebBricks
self.wbcnf = WbCfgManagerForm.WbCfgManagerForm(self.discover )
self.testwbcnf = MockWbConfig.MockWebBrickCfgEdit()
# self._log.warning( "**** System Configured ****" )
def stop(self):
"""
helper to shut down some class stuff.
"""
if self.despatch:
self.discover.stop(self.despatch)
self.despatch.stop()
@turbogears.expose(template="WebBrickConfig.templates.WbCfgWelcome")
def index(self):
return dict(now=time.ctime())
@turbogears.expose(template="WebBrickConfig.templates.quiet")
def quiet(self):
return dict()
# @turbogears.expose()
def default(self,*args):
raise cherrypy.HTTPRedirect(turbogears.url("/panels"))
def testTimeEvent4(self):
"""
Run test with time interval in seconds.
"""
self._log.debug( "\n\ntestTimeEvent4" )
loader = EventRouterLoader()
loader.loadHandlers( getDictFromXmlString(testConfigTime4) )
loader.start() # all tasks
self._router = loader.getEventRouter()
self.waitNEvents( 1 )
TestEventLogger.logEvents()
# first event should be isDark
self.assert_( len(TestEventLogger._events) > 0)
self.assertEqual( TestEventLogger._events[0].getType(), u'http://id.webbrick.co.uk/events/time/isDark' )
self.assertEqual( TestEventLogger._events[0].getSource(), "time/isDark" )
self.waitNEvents( 5 )
TestEventLogger.logEvents()
self.assert_( len(TestEventLogger._events) > 4)
evt = TestEventLogger._events[1]
od = evt.getPayload()
self.assertEqual( len(od["timestr"]),8 )
self.assertEqual( len(od["datestr"]),10 )
self.assertEqual( len(od["datetimestr"]),19 )
loader.stop() # all tasks
self.dumpEvents = False
class TestEventState(unittest.TestCase):
def setUp(self):
self._log = logging.getLogger( "TestEventState" )
self.router = None
self.loader = None
self.eventState = None
return
def tearDown(self):
if self.eventState:
self.eventState.stop( self.router )
self.eventState = None
if self.loader:
self.loader.stop() # all tasks
self.loader = None
self.router = None
time.sleep(1)
# Actual tests follow
def TestEventState(self):
# create testDespatch
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigEvent) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.eventState = EventState()
self.eventState.start( self.router );
# request URL from ..
q1 = self.eventState.queryCache( 'webbrick/100/DO/0', 'state' )
self.assertEqual( q1["stsval"], None )
self.assertEqual( q1["stserr"], 'Not Known' )
# send event
self.router.publish( EventSource("TestEventState"), EventHandlers.tests.Events.evtDO_0_off ) # 0 Off
# request good URL
q2 = self.eventState.queryCache( 'webbrick/100/DO/0', 'state' )
self.assertEqual( q2["stsval"], '0' )
self.assertEqual( q2["stserr"], None )
# request bad URL
q3 = self.eventState.queryCache( 'webbrick/100/DO/1', 'state' )
self.assertEqual( q3["stsval"], None )
self.assertEqual( q3["stserr"], 'Not Known' )
def testSingleDirectoryAbsoluteLocal(self):
_log.debug( "\ntestSingleDirectoryAbsoluteLocal" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigSingleDirectoryAbsolute) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.waitForFile(fname01)
self.router.publish( EventAgent("TestBackup"), Events.evtMinute1 ) # do initial backup
self.waitForFile(fname01)
self.loader.stop() # all tasks
self.loader = None
# now verify file exists.
self.failUnless( isfile( fname01 ) )
self.failUnless( zipfile.is_zipfile( fname01 ) )
# read zip info.
zf = zipfile.ZipFile(fname01, 'r' ) # read only
zfi = zf.infolist()
self.assertEqual( len(zfi), 2 ) # two entrys
self.failUnless( zfi[0].filename.endswith("/work/file1.txt") )
self.failUnless( zfi[1].filename.endswith("/work/file2.txt") )
zf.close()
def testSingleFileLocalDelete(self):
"""
Initial single file backup
"""
_log.debug( "\ntestSingleFileLocalDelete" )
copyfile( testdata1, testdata3 )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigSingleFileDelete) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestBackup"), Events.evtMinute1 ) # do initial backup
self.waitForFile(fname01)
self.loader.stop() # all tasks
self.loader = None
# now verify file exists.
self.failUnless( isfile( fname01 ) )
self.failUnless( zipfile.is_zipfile( fname01 ) )
# read zip info.
zf = zipfile.ZipFile(fname01, 'r' ) # read only
zfi = zf.infolist()
self.assertEqual( len(zfi), 1 ) # one entry
self.assertEqual( zfi[0].filename, "work/file1_delete.txt" )
self.failIf( isfile( testdata3 ) ) # should be deleted
zf.close()
def testCompress(self):
"""
Test database compression
"""
self._aofFilePath = "/home/tombushby/Documents/Redis/redis2rc/redis-2.0.0-rc2/appendonly.aof"
self._startSize = os.path.getsize(self._aofFilePath)
self.persistDatabaseEmpty()
self.persistDatabaseWrite4()
self.persistDatabaseWrite4()
self.persistDatabaseWrite4()
self.persistDatabaseWrite4()
self.persistDatabaseWrite4()
self._log.debug("\ntestDatabaseCompress")
self.loader = EventRouterLoader()
self.loader.loadHandlers(getDictFromXmlString(testPersistCfg))
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish(
EventAgent("TestPersistDatabase"),
Event("http://id.webbrick.co.uk/events/time/minute", "test/source", {"hour": 2, "minute": 5}),
)
time.sleep(5) # BGREWRITEAOF (compressing the AOF file) is a background process, it needs time
self._endSize = os.path.getsize(self._aofFilePath)
self.assertEqual(self._startSize > self._endSize, True)
def testStartStop(self):
self._log.debug( "\ntestStartStop" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigUPNP) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Play )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Next )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Next )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Pause )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Play )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Prev )
time.sleep(5)
self.router.publish( EventAgent("testITunes"), evt_Stop )
time.sleep(5)
def testTimerHoldPI(self):
self._log.debug( "\n\ntestTimerHoldPI" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigTimer2) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConEnable )
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConDuration )
self.router.publish( EventAgent("TestTimerAction"), Events.evtHome )
self.router.publish( EventAgent("TestTimerAction"), Events.evtDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtMorningDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_1_on ) # this should NOT create a hold state (because invert is set)
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_0_on ) # this should kick presence
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond0 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond1 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond2 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond3 ) # Create a 'second'
self.expectNevents( 13 )
self.assertEqual( TestEventLogger._events[11].getType(), u'http://id.webbrick.co.uk/events/timer' )
self.assertEqual( TestEventLogger._events[11].getSource(), "testing/timer/1" )
self.assertEqual( TestEventLogger._events[12].getType(), u'testing' )
self.assertEqual( TestEventLogger._events[12].getSource(), "result/timertest" )
def testWebbrickStatusQuery(self):
self._log.debug( "\n\ntestWebbrickStatusQuery" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigWebbrickStatusQuery) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestWebbrickStatusMonitor"), Events.evtSecond5 ) # so webbrick is in list for recover
self.router.publish( EventAgent("TestWebbrickStatusMonitor"), Events.evtMinute1 ) # do recover
waitNSeconds(2) # recover is async
self.router.publish( EventAgent("TestWebbrickStatusMonitor"), Events.evtSecond5 ) # do scan
waitNSeconds(2) # scan is async
# We should see lots of events here as initial pass.
# my test rig only has 1 temp sensors.
# so:
# 1 temp sensors
# 4 analogue in
# 4 analogue out
# 12 digital in
# 8 digital out
# 8 mimic out
self.assert_( TestEventLogger.expectAtLeastNevents(36+NUM_TEMP_SENSORS), "expecting %u events" % (36+NUM_TEMP_SENSORS) )
oldLen = len(TestEventLogger._events)
self.router.publish( EventAgent("TestWebbrickStatusMonitor"), Events.evtSecond5 ) # do scan
waitNSeconds(2) # scan is async
TestEventLogger.logEvents()
self.assert_( oldLen <= len(TestEventLogger._events) )
def testCompoundNewState(self):
self._log.debug( "\ntestCompoundNewState" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigCompoundEventNewState) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
# initial state is all things off.
self.router.publish( EventAgent("TestCompound"), Events.evtMinute1 )
TestEventLogger.logEvents()
self.expectNevents( 1 )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute2 )
self.expectNevents( 3 )
self.assertEqual( TestEventLogger._events[2].getType(), u'internal' )
self.assertEqual( TestEventLogger._events[2].getSource(), "testState" )
od = TestEventLogger._events[2].getPayload()
self.assertEqual( od["idx"], '1' )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute3 )
self.expectNevents( 4 )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute4 )
self.expectNevents( 6 )
self.assertEqual( TestEventLogger._events[5].getType(), u'internal' )
self.assertEqual( TestEventLogger._events[5].getSource(), "testState" )
od = TestEventLogger._events[5].getPayload()
self.assertEqual( od["idx"], 3 ) # previous minute
def testCompoundEvent2(self):
# What happens if an updated updates multiple bits of local state
# and gets repeated events
self._log.debug( "\n\ntestCompoundEvent2" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigCompoundEvent2) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
# initial state is all things off.
self.router.publish( EventAgent("TestCompound"), Events.evtMinute1 )
self.expectNevents( 1 )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute2 )
self.expectNevents( 3 )
self.assertEqual( TestEventLogger._events[2].getType(), u'http://simple' )
self.assertEqual( TestEventLogger._events[2].getSource(), "garage1/Open" )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute3 )
self.expectNevents( 5 )
self.assertEqual( TestEventLogger._events[4].getType(), u'http://simple' )
self.assertEqual( TestEventLogger._events[4].getSource(), "garage1/Closed" )
self.router.publish( EventAgent("TestCompound"), Events.evtMinute2 )
self.expectNevents( 7 )
self.assertEqual( TestEventLogger._events[6].getType(), u'http://simple' )
self.assertEqual( TestEventLogger._events[6].getSource(), "garage1/Open" )
def testConvertIntToHexBytes(self):
self._log.debug("\ntestConvertHexToInt")
self.loader = EventRouterLoader()
self.loader.loadHandlers(getDictFromXmlString(testConvertHexIntConfig2))
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish(EventAgent("TestValueConvert"), Events.evtINT_0) # dec 50, i.e. hex 32
self.router.publish(EventAgent("TestValueConvert"), Events.evtINT_50) # dec 50, i.e. hex 32
self.router.publish(EventAgent("TestValueConvert"), Events.evtINT_100) # dec 50, i.e. hex 32
self.expectNevents(6)
# first is subscribe event
self.assertEqual(TestEventLogger._events[0].getSource(), "testing/converion/dec_to_hex")
self.assertEqual(TestEventLogger._events[1].getSource(), "testing/converion/dec_to_hex")
self.assertEqual(TestEventLogger._events[2].getSource(), "testing/converion/dec_to_hex")
self.assertEqual(TestEventLogger._events[3].getType(), "local/value")
self.assertEqual(TestEventLogger._events[3].getSource(), "testing/converion/dec_to_hex/result")
self.assertEqual(TestEventLogger._events[3].getPayload()["val1"], 48)
self.assertEqual(TestEventLogger._events[3].getPayload()["val2"], 48)
self.assertEqual(TestEventLogger._events[3].getPayload()["oldval"], "0")
self.assertEqual(TestEventLogger._events[4].getType(), "local/value")
self.assertEqual(TestEventLogger._events[4].getSource(), "testing/converion/dec_to_hex/result")
self.assertEqual(TestEventLogger._events[4].getPayload()["val1"], 51)
self.assertEqual(TestEventLogger._events[4].getPayload()["val2"], 50)
self.assertEqual(TestEventLogger._events[4].getPayload()["oldval"], "50")
self.assertEqual(TestEventLogger._events[5].getType(), "local/value")
self.assertEqual(TestEventLogger._events[5].getSource(), "testing/converion/dec_to_hex/result")
self.assertEqual(TestEventLogger._events[5].getPayload()["val1"], 54)
self.assertEqual(TestEventLogger._events[5].getPayload()["val2"], 52)
self.assertEqual(TestEventLogger._events[5].getPayload()["oldval"], "100")
def testConvertHexToInt(self):
self._log.debug("\ntestConvertHexToInt")
self.loader = EventRouterLoader()
self.loader.loadHandlers(getDictFromXmlString(testConvertHexIntConfig1))
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish(EventAgent("TestValueConvert"), Events.evtHEX_0) # Hex 0 i.e. dec 0
self.router.publish(EventAgent("TestValueConvert"), Events.evtHEX_32) # Hex 32 i.e. dec 50
self.router.publish(EventAgent("TestValueConvert"), Events.evtHEX_64) # Hex 64 i.e. dec 100
self.expectNevents(6)
# first is subscribe event
self.assertEqual(TestEventLogger._events[0].getSource(), "testing/converion/hex_to_dec")
self.assertEqual(TestEventLogger._events[1].getSource(), "testing/converion/hex_to_dec")
self.assertEqual(TestEventLogger._events[2].getSource(), "testing/converion/hex_to_dec")
self.assertEqual(TestEventLogger._events[3].getType(), "local/value")
self.assertEqual(TestEventLogger._events[3].getSource(), "testing/converion/hex_to_dec/result")
self.assertEqual(TestEventLogger._events[3].getPayload()["val"], 0)
self.assertEqual(TestEventLogger._events[3].getPayload()["oldval"], "0")
self.assertEqual(TestEventLogger._events[4].getType(), "local/value")
self.assertEqual(TestEventLogger._events[4].getSource(), "testing/converion/hex_to_dec/result")
self.assertEqual(TestEventLogger._events[4].getPayload()["val"], 50)
self.assertEqual(TestEventLogger._events[4].getPayload()["oldval"], "32")
self.assertEqual(TestEventLogger._events[5].getType(), "local/value")
self.assertEqual(TestEventLogger._events[5].getSource(), "testing/converion/hex_to_dec/result")
self.assertEqual(TestEventLogger._events[5].getPayload()["val"], 100)
self.assertEqual(TestEventLogger._events[5].getPayload()["oldval"], "64")
def testDeltaTime2(self):
"""
Test the delta time event generator.
"""
self._log.debug( "\n\ntestDeltaTime2" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigDeltaTime2) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestDelayedEvent"), Events.evtTD0 ) # TD0 0 Off
# time events are not in the log.
TestEventLogger.logEvents()
self.assertEqual( len(TestEventLogger._events), 2)
self.assertEqual( TestEventLogger._events[0].getType(), "http://id.webbrick.co.uk/events/webbrick/TD" )
self.assertEqual( TestEventLogger._events[1].getType(), "http://id.webbrick.co.uk/events/time/delta" )
self.router.publish( EventAgent("TestDelayedEvent"), Events.evtMinute ) # minute
self.router.publish( EventAgent("TestDelayedEvent"), Events.evtMinute ) # minute
# delayed event should now be here.
self.assertEqual( len(TestEventLogger._events), 4)
self.assertEqual( TestEventLogger._events[2].getType(), "delta/delay" )
self.assertEqual( TestEventLogger._events[2].getSource(), "delta/delay1" )
self.assertEqual( TestEventLogger._events[3].getType(), "delta/delay" )
self.assertEqual( TestEventLogger._events[3].getSource(), "delta/delay2" )
def testHttpAction2RequestsSpaced(self):
self._log.debug( "\ntestHttpAction2RequestsSpaced" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigHttpAction) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
time.sleep(1)
self.router.publish( EventAgent("TestHttpAction"), Events.evtTD0 ) # 0 Off
maxTime = 10
while (len(self.httpServer.requests()) < 1) and (maxTime > 0):
maxTime -= 1
time.sleep(1)
self.router.publish( EventAgent("TestHttpAction"), Events.evtTD0 ) # 0 Off
maxTime = 10
while (len(self.httpServer.requests()) < 2) and (maxTime > 0):
maxTime -= 1
time.sleep(1)
TestEventLogger.logEvents()
# now look for correct url requests
self._log.debug( "testHttpAction %s", self.httpServer.requests() )
self.assertEqual( len(self.httpServer.requests()), 2)
self.assertEqual( self.httpServer.requests()[0], "/test?medianame=ITunes&mediacmd=volup" )
self.assertEqual( self.httpServer.requests()[1], "/test?medianame=ITunes&mediacmd=volup" )
def testTimeSignalResetSiteplayer(self):
# see we get siteplayer reset when no messages from siteplayer for a while
self._log.debug( "\ntestTimeSignalResetSiteplayer" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigSetTime) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
logHandler = testLogHandler()
addTestLogHandler(logHandler,'EventHandlers')
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime ) # get detected
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
# check http requests, should be none so far
self.expectNhttp(0)
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.expectNhttp(2)
self.assertEqual( self.httpServer.requests()[0], "/hid.spi?com=%3ALG%3bpassword%3A" )
self.assertEqual( self.httpServer.requests()[1], "/hid.spi?com=%3ARS%3A" )
removeTestLogHandler(logHandler,'EventHandlers')
def testTimerEvent(self):
self._log.debug( "\n\ntestTimerEvent" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigTimer) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConEnable )
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConDuration )
self.router.publish( EventAgent("TestTimerAction"), Events.evtHome )
self.router.publish( EventAgent("TestTimerAction"), Events.evtDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtMorningDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_0_on ) # this should kick presence but not create an event
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_0_off ) # this should kick presence because invert is true
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_0_off ) # this should kick presence because invert is true (twice because this happens)
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond0 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond1 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond2 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond3 ) # Create a 'second'
time.sleep(1)
self.expectNevents( 14 )
self.assertEqual( TestEventLogger._events[12].getType(), u'http://id.webbrick.co.uk/events/timer' )
self.assertEqual( TestEventLogger._events[12].getSource(), "testing/timer/1" )
self.assertEqual( TestEventLogger._events[13].getType(), u'testing' )
self.assertEqual( TestEventLogger._events[13].getSource(), "result/timertest" )
def testSolarNightEvent(self):
self._log.debug( "\n\ntestSolarTankHighEvent" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigUnderFloor) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.common_set(pump=True, pipe='Hot', tank='Normal')
time.sleep(1)
self.router.publish( EventAgent("TestUnderFloorAction"), Events.evtCT_0_80 ) # Pipe Temp
time.sleep(1)
self.router.publish( EventAgent("TestUnderFloorAction"), Events.evtDark )
time.sleep(1)
self.router.publish( EventAgent("TestUnderFloorAction"), Events.evtSecond5 ) # Create a 'second'
time.sleep(1)
self.router.publish( EventAgent("TestUnderFloorAction"), Events.evtMinute1 ) # Create a 'minute'
time.sleep(1)
#self.display_events(TestEventLogger._events)
#self.expectNevents( 25 )
self.assertEqual( TestEventLogger._events[19].getType(), u'http://id.webbrick.co.uk/events/UnderFloor' )
self.assertEqual( TestEventLogger._events[19].getSource(), u"testing/UnderFloor" )
self.assertEqual( TestEventLogger._events[19].getPayload()['set_pump_state'], u"stop" )
def testTimerEventWithAnalogue(self):
self._log.debug( "\n\ntestTimerEventWithAnalogue" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigTimer4) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConEnable )
self.router.publish( EventAgent("TestTimerAction"), Events.evtTimerConDuration )
self.router.publish( EventAgent("TestTimerAction"), Events.evtHome )
self.router.publish( EventAgent("TestTimerAction"), Events.evtDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtMorningDark )
self.router.publish( EventAgent("TestTimerAction"), Events.evtAI_0_10 ) # this should show light off,
self.router.publish( EventAgent("TestTimerAction"), Events.evtAI_0_90 ) # this should kick light on,
self.router.publish( EventAgent("TestTimerAction"), Events.evtAI_0_90 ) # this should kick light on, twice because it can happen
self.router.publish( EventAgent("TestTimerAction"), Events.evtDO_0_off ) # this should kick presence
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond0 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond1 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond2 ) # Create a 'second'
self.router.publish( EventAgent("TestTimerAction"), Events.evtSecond3 ) # Create a 'second'
self.expectNevents( 15 )
self.assertEqual( TestEventLogger._events[13].getType(), u'http://id.webbrick.co.uk/events/timer' )
self.assertEqual( TestEventLogger._events[13].getSource(), "testing/timer/1" )
self.assertEqual( TestEventLogger._events[14].getType(), u'testing' )
self.assertEqual( TestEventLogger._events[14].getSource(), "result/timertest" )
def testFloatCounterSet(self):
"""
Set Counter to a fixed value
"""
_log.debug( "\ntestFloatCounterSet" )
self.loader = EventRouterLoader()
errCount = self.loader.loadHandlers( getDictFromXmlString(testConfigFloatCounterSet) )
self.assertEqual( errCount, 0)
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("testCounters"), makeEvent( 'test/event', 'set/counter', { 'val':'300.45' } ) )
TestEventLogger.logEvents()
expectedEvents = {
"test/event" :
[
("set/counter" , 'val', 300.45)
],
"test/1" :
[ ("test/entryCount",'val', 300.45)
]
}
Utils.expectNevents(self, 2)
haveErr, excessEvents = Utils.verifyEvents2( expectedEvents, TestEventLogger._events )
_log.debug( "Excess Events %s " % (excessEvents) )
self.assertEqual( haveErr, False, "Incorrect event set" )
def testDatabaseWriteLoop(self):
"""
Test to write x number of NvPs to empty database, default 2000
"""
self.persistDatabaseEmpty()
self._log.debug("\ntestDatabaseWriteLoop")
self.loader = EventRouterLoader()
self.loader.loadHandlers(getDictFromXmlString(testPersistCfg))
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
for i in range(0, 2000):
self.router.publish(
EventAgent("TestPersistDatabase"),
Event(
"http://id.webbrick.co.uk/events/config/set",
"test/source" + str(i) + ".new",
{"name" + str(i): "value" + str(i) + ".0"},
),
)
self.expectNevents(4000)
for i in range(0, 2000):
self.assertEqual(
self.queryDatabase("http://id.webbrick.co.uk/events/config/set,test/source" + str(i) + ".new"),
{"name" + str(i): "value" + str(i) + ".0"},
)
def testIntCounterDec2Reset(self):
_log.debug( "\ntestIntCounterDec2Reset" )
self.loader = EventRouterLoader()
errCount = self.loader.loadHandlers( getDictFromXmlString(testConfigDecrement2Reset) )
self.assertEqual( errCount, 0)
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("testCounters"), Events.evtTD0 )
self.router.publish( EventAgent("testCounters"), Events.evtTD0 )
self.router.publish( EventAgent("testCounters"), Events.evtHour03 )
TestEventLogger.logEvents()
expectedEvents = {
"http://id.webbrick.co.uk/events/webbrick/TD" :
[
("webbrick/100/TD/0" , None, None),
("webbrick/100/TD/0" , None, None)
],
"http://id.webbrick.co.uk/events/time/hour" :
[ ("time/hour",None, None)
],
"test/entryCount" :
[ ("test/entryCount",'val', 98)
, ("test/entryCountTotal",'val', 100)
],
}
Utils.expectNevents(self, 5)
haveErr, excessEvents = Utils.verifyEvents2( expectedEvents, TestEventLogger._events )
_log.debug( "Excess Events %s " % (excessEvents) )
self.assertEqual( haveErr, False, "Incorrect event set" )
def testCommandLine(self):
"""
Initial single file backup using command line disposal
"""
_log.debug( "\ntestCommandLine" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigCommandLine) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestBackup"), Events.evtMinute1 ) # do initial backup
self.waitForFile(fname01)
self.loader.stop() # all tasks
self.loader = None
# now verify file exists.
self.failUnless( isfile( fname01 ) )
self.failUnless( zipfile.is_zipfile( fname01 ) )
# read zip info.
zf = zipfile.ZipFile(fname01, 'r' ) # read only
zfi = zf.infolist()
self.assertEqual( len(zfi), 1 ) # one entry
self.assertEqual( zfi[0].filename, "work/file1.txt" ) # one entry
zf.close()
def testOnkyo(self):
self._log.debug( "\ntestOnkyo" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigOnkyo) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("testVolume"), evtOnkyoVolume0 )
# time events are not in the log.
self.assert_(TestEventLogger.expectNevents(2))
self.assertEqual( TestEventLogger._events[0].getSource(), "webbrick/1/100" )
evt = TestEventLogger._events[1]
self.assertEqual( evt.getType(), "avamplifier/volume/current" )
self.assertEqual( evt.getSource(), "avamplifier/1/volume/main/current" )
evtod = evt.getPayload()
self.assert_( evtod.has_key("val") )
self.assertEqual( evtod["val"], 0 )
self.router.publish( EventAgent("testVolume"), evtOnkyoVolume50 )
self.assert_(TestEventLogger.expectNevents(4))
self.router.publish( EventAgent("testVolume"), evtOnkyoVolume100 )
self.assert_(TestEventLogger.expectNevents(6))
TestEventLogger.logEvents()
def testMixedDataSetLocal(self):
_log.debug( "\ntestMixedDataSetLocal" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigMixed) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestBackup"), Events.evtMinute1 ) # do initial backup
self.waitForFile(fname01)
self.loader.stop() # all tasks
self.loader = None
# now verify file exists.
self.failUnless( isfile( fname01 ) )
self.failUnless( zipfile.is_zipfile( fname01 ) )
# read zip info.
zf = zipfile.ZipFile(fname01, 'r' ) # read only
zfi = zf.infolist()
self.assertEqual( len(zfi), 4 )
self.assertEqual( zfi[0].filename, "work/file1.txt" )
self.assertEqual( zfi[1].filename, "work/file2.txt" )
self.assertEqual( zfi[2].filename, "file1.1.txt" )
self.assertEqual( zfi[3].filename, "file1.2.txt" )
zf.close()
def testEggNunciateTwo(self):
self._log.debug( "\ntestEggNunciateTwo" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigEggNunciate2) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestEggNunciate"), Events.evtRuntime5 ) # set up base scene
self.router.publish( EventAgent("TestEggNunciate"), Events.evtSecond5 )
# expect single HTTP request for default scene step 1.
self._log.debug( "testHttpAction %s", self.httpServer.requests() )
self.expectNhttp( 2)
self.assertEqual( self.httpServer.requests()[0], "/hid.spi?com=:DM3;16;4;16;5;16:" )
self.assertEqual( self.httpServer.requests()[1], "/hid.spi?com=:DM0;16;1;16;2;16:" )
self.router.publish( EventAgent("TestEggNunciate"), Events.evtSecond5 )
# expect second HTTP request for default scene step 2.
self._log.debug( "testHttpAction %s", self.httpServer.requests() )
self.expectNhttp( 4)
self.assertEqual( self.httpServer.requests()[3], "/hid.spi?com=:DM0;8;1;8;2;8:" )
self.assertEqual( self.httpServer.requests()[2], "/hid.spi?com=:DM3;8;4;8;5;8:" )
self.router.publish( EventAgent("TestEggNunciate"), Events.evtSecond5 )
# expect third HTTP request for default scene step 1.
self._log.debug( "testHttpAction %s", self.httpServer.requests() )
self.expectNhttp( 6)
self.assertEqual( self.httpServer.requests()[5], "/hid.spi?com=:DM0;16;1;16;2;16:" )
self.assertEqual( self.httpServer.requests()[4], "/hid.spi?com=:DM3;16;4;16;5;16:" )
def testSend(self):
self._log.debug( "\ntestListen" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigAsteriskSend) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
skt.connect(("localhost", 20998))
skt.send( " agi_request: dialparties.agi\n" )
skt.send( " agi_channel: SIP/100-b7a017f8\n" )
skt.send( " agi_language: en\n" )
skt.send( " agi_type: SIP\n" )
skt.send( " agi_uniqueid: 1173178145.6\n" )
skt.send( " agi_callerid: 100\n" )
skt.send( " agi_calleridname: SNOM\n" )
skt.send( " agi_callingpres: 0\n" )
skt.send( " agi_callingani2: 0\n" )
skt.send( " agi_callington: 0\n" )
skt.send( " agi_callingtns: 0\n" )
skt.send( " agi_dnid: 200\n" )
skt.send( " agi_rdnis: unknown\n" )
skt.send( " agi_context: macro-dial\n" )
skt.send( " agi_extension: s\n" )
skt.send( " agi_priority: 1\n" )
skt.send( " agi_enhanced: 0.0\n" )
skt.send( " agi_accountcode:\n" )
skt.send( "\n" )
skt.close()
time.sleep(2)
TestEventLogger.logEvents()
self.assert_( len(TestEventLogger._events) >= 1)
def testEggNunciateGarage(self):
self._log.debug( "\ntestEggNunciateEvent" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigEggNunciate1) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.router.publish( EventAgent("TestEggNunciate"), Events.evtRuntime5 ) # set up base scene
self.router.publish( EventAgent("TestEggNunciate"), Events.evtSecond5 )
# expect HTTP request for default scene 1 step 1.
self._log.debug( "testHttpAction %s", self.httpServer.requests() )
self.expectNhttp( 1)
hReq = self.httpServer.requests()[len(self.httpServer.requests())-1]
self.assertEqual( hReq, "/hid.spi?com=:DM0;16;1;16;2;16:" )
self.subTestGarageOpen()
self.expectNhttp( 7)
self.subTestGarageClose()
self.expectNhttp( 11)
self.subTestGarageOpen()
self.expectNhttp( 17)
self.subTestGarageClose()
self.expectNhttp( 21)
def TestEventState(self):
# create testDespatch
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigEvent) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.eventState = EventState()
self.eventState.start( self.router );
# request URL from ..
q1 = self.eventState.queryCache( 'webbrick/100/DO/0', 'state' )
self.assertEqual( q1["stsval"], None )
self.assertEqual( q1["stserr"], 'Not Known' )
# send event
self.router.publish( EventSource("TestEventState"), EventHandlers.tests.Events.evtDO_0_off ) # 0 Off
# request good URL
q2 = self.eventState.queryCache( 'webbrick/100/DO/0', 'state' )
self.assertEqual( q2["stsval"], '0' )
self.assertEqual( q2["stserr"], None )
# request bad URL
q3 = self.eventState.queryCache( 'webbrick/100/DO/1', 'state' )
self.assertEqual( q3["stsval"], None )
self.assertEqual( q3["stserr"], 'Not Known' )
def testTimeSignalSetTime(self):
# see we get time reset when out by more than 60 nseconds for 5 minutes.
self._log.debug( "\ntestTimeSignalReboot" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigSetTime) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
logHandler = testLogHandler()
addTestLogHandler(logHandler,'EventHandlers')
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime )
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime )
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime )
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
# check http requests, should be none so far
self.expectNhttp(0)
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime )
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtST_10MinUpTime )
self.router.publish( EventAgent("TestWebbrickMonitor"), Events.evtMinute11 ) # request
self.expectNhttp(2)
self.assertEqual( self.httpServer.requests()[0], "/hid.spi?com=%3ALG%3bpassword%3A" )
self.assertEqual( self.httpServer.requests()[1], "/hid.spi?com=%3AST1%3b4%3b11%3A" )
removeTestLogHandler(logHandler,'EventHandlers')
