Test for Stats Eventer deed

salt/daemons/flo/core.py

@@ -1594,7 +1594,7 @@ class SaltRaetStatsEventerMinion(SaltRaetStatsEventer):
             return
 
         route = {'dst': (s_estate, s_yard, 'event_fire'),
-                 'src': (self.road_stack.value.name, self.road_stack.value.local.name, None)}
+                 'src': (self.road_stack.value.name, self.lane_stack.value.name, None)}
         repl = {'route': route, 'tag': msg.get('tag'), 'data': stats}
         self.road_stack.value.transmit(repl,
                                        self.road_stack.value.fetchUidByName(s_estate))

salt/daemons/flo/master.flo

@@ -125,6 +125,7 @@ framer uxdrouter be inactive first start
 framer events be inactive first start
     frame start
         do salt raet eventer master
+        do salt raet stats eventer master
 
 # Presence framer
 framer presence be inactive first start
@@ -134,7 +135,6 @@ framer presence be inactive first start
 
     frame raet
        do salt raet presenter
-       do salt raet stats eventer master
 
     frame multiheaded
         let me if .salt.etc.zmq_behavior

salt/daemons/test/plan/actors.py

@@ -17,11 +17,14 @@ from ioflo.base.odicting import odict
 from ioflo.base.consoling import getConsole
 console = getConsole()
 
-from raet import nacling
-from raet.stacking import Stack
+from raet import raeting, nacling
 from raet.lane.stacking import LaneStack
 from raet.lane.yarding import RemoteYard
+from raet.road.estating import RemoteEstate
+from raet.road.stacking import RoadStack
+from raet.stacking import Stack
 
+from salt.daemons import salting
 from salt.utils.event import tagify
 
 
@@ -38,7 +41,7 @@ def createStack(ip):
     return stack
 
 
-class PresenterTestOptsSetup(ioflo.base.deeding.Deed):
+class TestOptsSetup(ioflo.base.deeding.Deed):
     '''
     Setup opts share
     '''
@@ -49,7 +52,7 @@ class PresenterTestOptsSetup(ioflo.base.deeding.Deed):
         Register presence requests
         Iterate over the registered presence yards and fire!
         '''
-        pkiDirpath = os.path.join('/tmp', 'raet', 'test', 'master', 'pki')
+        pkiDirpath = os.path.join('/tmp', 'raet', 'test', self.role, 'pki')
         if not os.path.exists(pkiDirpath):
             os.makedirs(pkiDirpath)
 
@@ -73,22 +76,22 @@ class PresenterTestOptsSetup(ioflo.base.deeding.Deed):
             mode = os.stat(localFilepath).st_mode
             print(mode)
 
-        cacheDirpath = os.path.join('/tmp/raet', 'cache', 'master')
+        cacheDirpath = os.path.join('/tmp/raet', 'cache', self.role)
         if not os.path.exists(cacheDirpath):
             os.makedirs(cacheDirpath)
 
-        sockDirpath = os.path.join('/tmp/raet', 'sock', 'master')
+        sockDirpath = os.path.join('/tmp/raet', 'sock', self.role)
         if not os.path.exists(sockDirpath):
             os.makedirs(sockDirpath)
 
         self.opts.value = dict(
-            id='master',
-            __role='master',
+            id=self.role,
+            __role=self.role,
             ioflo_period=0.1,
             ioflo_realtime=True,
             ioflo_verbose=2,
             interface="",
-            raet_port=7530,
+            raet_port=self.raet_port,
             transport='raet',
             client_acl=dict(),
             pki_dir=pkiDirpath,
@@ -98,8 +101,51 @@ class PresenterTestOptsSetup(ioflo.base.deeding.Deed):
             auto_accept=True,
             )
 
+        name = "{0}_{1}".format(self.role, self.role)
+        basedirpath = os.path.abspath(os.path.join(cacheDirpath, 'raet'))
+        keep = salting.SaltKeep(opts=self.opts.value,
+                                basedirpath=basedirpath,
+                                stackname=name)
+        keep.clearLocalData()
+        keep.clearLocalRoleData()
+        keep.clearAllRemoteData()
+        keep.clearAllRemoteRoleData()
 
-def serviceStacks(stacks, duration=1.0):
+
+class TestOptsSetupMaster(TestOptsSetup):
+
+    def action(self):
+        self.role = 'master'
+        self.raet_port = raeting.RAET_PORT
+        super(TestOptsSetupMaster, self).action()
+
+
+class TestOptsSetupMinion(TestOptsSetup):
+
+    def action(self):
+        self.role = 'minion'
+        self.raet_port = raeting.RAET_TEST_PORT
+        super(TestOptsSetupMinion, self).action()
+
+
+def serviceRoads(stacks, duration=1.0):
+    '''
+    Utility method to service queues for list of stacks. Call from test method.
+    '''
+    start = time.time()
+    while start + duration > time.time():
+        for stack in stacks:
+            stack.serviceAll()
+        if all([not stack.transactions for stack in stacks]):
+            console.terse("Service stacks done normally\n")
+            break
+        time.sleep(0.05)
+    for stack in stacks:
+        console.terse("Stack {0} remotes: {1}\n".format(stack.name, stack.nameRemotes))
+    console.terse("Service stacks exit\n")
+
+
+def serviceLanes(stacks, duration=1.0):
     '''
     Utility method to service queues for list of stacks. Call from test method.
     '''
@@ -161,7 +207,7 @@ class PresenterTestSetup(ioflo.base.deeding.Deed):
                  'src': (None, stack.local.name, None)}
         msg = {'route': route}
         stack.transmit(msg, stack.nameRemotes[ryn].uid)
-        serviceStacks([stack, self.lane_stack.value])
+        serviceLanes([stack, self.lane_stack.value])
 
 
 class PresenterTestCleanup(ioflo.base.deeding.Deed):
@@ -699,3 +745,83 @@ class TestPresenceAllowedOneMinionCheck(ioflo.base.deeding.Deed, DeedTestWrapper
                                           'dst': [None, None, 'event_fire']},
                                 'tag': tag,
                                 'data': {'allowed': {'alpha':'1.1.1.1'}}})
+
+
+class StatsMasterTestSetup(ioflo.base.deeding.Deed):
+    '''
+    Setup shares for stats tests
+    '''
+    Ioinits = {'stats_req': '.salt.stats.event_req',
+               'lane_stack': '.salt.lane.manor.stack',
+               'road_stack': '.salt.road.manor.stack',
+               'event_stack': '.salt.test.lane.stack'}
+
+    def action(self):
+
+        self.stats_req.value = deque()
+
+        # Create event stack
+        name = 'event' + nacling.uuid(size=18)
+        lanename = self.lane_stack.value.local.lanename
+        sock_dir = self.lane_stack.value.local.dirpath
+        ryn = 'manor'
+        console.terse("Create stack: name = {0}, lanename = {1}, sock_dir = {2}\n".
+                      format(name, lanename, sock_dir))
+        stack = LaneStack(
+            name=name,
+            lanename=lanename,
+            sockdirpath=sock_dir)
+        stack.addRemote(RemoteYard(stack=stack,
+                                   lanename=lanename,
+                                   name=ryn,
+                                   dirpath=sock_dir))
+        self.event_stack.value = stack
+
+        route = {'dst': (None, ryn, 'stats_req'),
+                 'src': (None, stack.local.name, None)}
+        msg = {'route': route}
+        stack.transmit(msg, stack.nameRemotes[ryn].uid)
+        serviceLanes([stack, self.lane_stack.value])
+
+
+class StatsMinionTestSetup(ioflo.base.deeding.Deed):
+    '''
+    Setup shares for stats tests
+    '''
+    Ioinits = {'stats_req': '.salt.stats.event_req',
+               'lane_stack': '.salt.lane.manor.stack',
+               'road_stack': '.salt.road.manor.stack',
+               'event_stack': '.salt.test.road.stack'}
+
+    def action(self):
+
+        self.stats_req.value = deque()
+
+        minionStack = self.road_stack.value
+
+        # Create Master Stack
+        self.store.stamp = 0.0
+        masterStack = RoadStack(store=self.store,
+                                name='master',
+                                ha=('', raeting.RAET_PORT),
+                                role='master',
+                                main=True,
+                                cleanremote=True,
+                                period=3.0,
+                                offset=0.5)
+        self.event_stack.value = masterStack
+
+        minionRemoteMaster = RemoteEstate(stack=minionStack,
+                                          fuid=0,
+                                          sid=0,
+                                          ha=masterStack.local.ha)
+        minionStack.addRemote(minionRemoteMaster)
+
+        # Make life easier
+        masterStack.keep.auto = raeting.autoModes.always
+        minionStack.keep.auto = raeting.autoModes.always
+
+        minionStack.join(minionRemoteMaster.uid)
+        serviceRoads([minionStack, masterStack])
+        minionStack.allow(minionRemoteMaster.uid)
+        serviceRoads([minionStack, masterStack])

salt/daemons/test/plan/box1.flo

@@ -4,7 +4,7 @@ house presence
 
 framer presenter be active first setup
     frame setup
-        do presenter test opts setup
+        do test opts setup master
         do salt raet manor lane setup per inode ".salt.lane.manor"
         do presenter test setup
         go next

salt/daemons/test/test_presence.py

@@ -76,9 +76,9 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         """
         console.terse("{0}\n".format(self.testContextSetup.__doc__))
 
-        act = self.addEnterDeed("PresenterTestOptsSetup")
+        act = self.addEnterDeed("TestOptsSetupMaster")
         self.assertIn(act, self.frame.enacts)
-        self.assertEqual(act.actor, "PresenterTestOptsSetup")
+        self.assertEqual(act.actor, "TestOptsSetupMaster")
         act = self.addEnterDeed("SaltRaetManorLaneSetup")
         self.assertIn(act, self.frame.enacts)
         self.assertEqual(act.actor, "SaltRaetManorLaneSetup")
@@ -126,7 +126,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAvailable.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -195,7 +195,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceJoined.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -246,7 +246,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAllowed.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -296,7 +296,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAlived.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -346,7 +346,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceReaped.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -396,7 +396,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceNoRequest.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -426,7 +426,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceUnknownSrc.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -466,7 +466,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAvailableNoMinions.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -511,7 +511,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAvailableOneMinion.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -559,7 +559,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAvailableSomeIpUnknown.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -612,7 +612,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAllowedNoMinions.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")
@@ -658,7 +658,7 @@ class PresenterTestCase(testing.FrameIofloTestCase):
         console.terse("{0}\n".format(self.testPresenceAllowedOneMinion.__doc__))
 
         # Bootstrap
-        self.addEnterDeed("PresenterTestOptsSetup")
+        self.addEnterDeed("TestOptsSetupMaster")
         self.addEnterDeed("SaltRaetManorLaneSetup")
         self.addEnterDeed("PresenterTestSetup")
         act = self.addRecurDeed("SaltRaetPresenter")

salt/daemons/test/test_stats.py

@@ -0,0 +1,735 @@
+# -*- coding: utf-8 -*-
+"""
+Raet Ioflo Behavior Unittests
+"""
+# pylint: skip-file
+# pylint: disable=C0103
+
+import sys
+if sys.version_info < (2, 7):
+    import unittest2 as unittest
+else:
+    import unittest
+
+from ioflo.base.consoling import getConsole
+console = getConsole()
+from ioflo.base.odicting import odict
+from ioflo.test import testing
+
+from raet.abiding import ns2u
+from raet.lane.stacking import LaneStack
+from raet.road.stacking import RoadStack
+from raet.stacking import Stack
+
+from salt.utils.event import tagify
+
+# Import Ioflo Deeds
+from salt.daemons.flo import core
+from salt.daemons.test.plan import actors
+
+
+def setUpModule():
+    console.reinit(verbosity=console.Wordage.concise)
+
+
+def tearDownModule():
+    pass
+
+
+class StatsEventerTestCase(testing.FrameIofloTestCase):
+    """
+    Test case for Salt Raet Stats Eventer Master and Minion deeds
+    """
+
+    def setUp(self):
+        """
+        Call super if override so House Framer and Frame are setup correctly
+        """
+        super(StatsEventerTestCase, self).setUp()
+
+
+    def tearDown(self):
+        """
+        Call super if override so House Framer and Frame are torn down correctly
+        """
+        super(StatsEventerTestCase, self).tearDown()
+
+
+    def testMasterContextSetup(self):
+        """
+        Test the context setup procedure used in all the consequence tests works as expected
+        This test intended to avoid some checks in other tests
+        """
+        console.terse("{0}\n".format(self.testMasterContextSetup.__doc__))
+
+        act = self.addEnterDeed("TestOptsSetupMaster")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "TestOptsSetupMaster")
+        act = self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "SaltRaetManorLaneSetup")
+        act = self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "SaltRaetRoadStackSetup")
+        act = self.addEnterDeed("StatsMasterTestSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "StatsMasterTestSetup")
+
+        act = self.addRecurDeed("SaltRaetStatsEventer")
+        self.assertIn(act, self.frame.reacts)
+        self.assertEqual(act.actor, "SaltRaetStatsEventer")
+
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+
+        self.frame.enter()
+        self.assertDictEqual(act.actor.Ioinits,
+                             {'opts': '.salt.opts',
+                              'stats_req': '.salt.stats.event_req',
+                              'lane_stack': '.salt.lane.manor.stack',
+                              'road_stack': '.salt.road.manor.stack'})
+
+        self.assertTrue(hasattr(act.actor, 'opts'))
+        self.assertTrue(hasattr(act.actor, 'stats_req'))
+        self.assertTrue(hasattr(act.actor, 'lane_stack'))
+        self.assertTrue(hasattr(act.actor, 'road_stack'))
+        self.assertIsInstance(act.actor.lane_stack.value, LaneStack)
+        self.assertIsInstance(act.actor.road_stack.value, RoadStack)
+        self.frame.recur()
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMasterRoadStats(self):
+        """
+        Test Master Road Stats request (A1)
+        """
+        console.terse("{0}\n".format(self.testMasterRoadStats.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMaster")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMasterTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMaster")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats['test_stats_event'] = 111
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.lane.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('road', 'stats')
+        # road stats request
+        statsReq.append({'route': {'dst': (None, None, 'stats_req'),
+                                   'src': (None, testStack.local.name, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 1)
+
+        msg, sender = testStack.rxMsgs.popleft()
+        self.assertDictEqual(msg, {'route': {'src': [None, 'manor', None],
+                                             'dst': [None, None, 'event_fire']},
+                                   'tag': tag,
+                                   'data': {'test_stats_event': 111}})
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMasterLaneStats(self):
+        """
+        Test Master Road Stats request (A2)
+        """
+        console.terse("{0}\n".format(self.testMasterLaneStats.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMaster")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMasterTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMaster")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        laneStack.value.stats['test_stats_event'] = 111
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {})
+        self.assertDictEqual(laneStack.value.stats, {'test_stats_event': 111})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.lane.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('lane', 'stats')
+        # lane stats request
+        statsReq.append({'route': {'dst': (None, None, 'stats_req'),
+                                   'src': (None, testStack.local.name, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 1)
+
+        msg, sender = testStack.rxMsgs.popleft()
+        self.assertDictEqual(msg, {'route': {'src': [None, 'manor', None],
+                                             'dst': [None, None, 'event_fire']},
+                                   'tag': tag,
+                                   'data': {'test_stats_event': 111}})
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMasterStatsWrongMissingTag(self):
+        """
+        Test Master Stats requests with unknown and missing tag (A3, A4)
+        """
+        console.terse("{0}\n".format(self.testMasterStatsWrongMissingTag.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMaster")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMasterTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMaster")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats['test_road_stats_event'] = 111
+        laneStack.value.stats['test_lane_stats_event'] = 222
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.lane.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = 'salt/unknown/tag'
+        self.assertNotEqual(tag, tagify('lane', 'stats'))
+        self.assertNotEqual(tag, tagify('road', 'stats'))
+        # unknown tag in stats request
+        statsReq.append({'route': {'dst': (None, None, 'stats_req'),
+                                   'src': (None, testStack.local.name, None)},
+                         'tag': tag})
+        # no tag in stats request
+        statsReq.append({'route': {'dst': (None, None, 'stats_req'),
+                                   'src': (None, testStack.local.name, None)}})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMasterStatsUnknownRemote(self):
+        """
+        Test Master Stats request with unknown remote (B1)
+        """
+        console.terse("{0}\n".format(self.testMasterStatsUnknownRemote.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMaster")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMasterTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMaster")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats['test_road_stats_event'] = 111
+        laneStack.value.stats['test_lane_stats_event'] = 222
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.lane.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('road', 'stats')
+        # unknown tag in stats request
+        unknownName = 'unknownName'
+        statsReq.append({'route': {'dst': (None, None, 'stats_req'),
+                                   'src': (None, unknownName, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMasterStatsNoRequest(self):
+        """
+        Test Master Stats no requests (nothing to do) (B2)
+        """
+        console.terse("{0}\n".format(self.testMasterStatsNoRequest.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMaster")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMasterTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMaster")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats['test_road_stats_event'] = 111
+        laneStack.value.stats['test_lane_stats_event'] = 222
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.lane.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        # no requests
+        self.assertEqual(len(statsReq), 0)
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.lane.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionContextSetup(self):
+        """
+        Test the context setup procedure used in all the consequence tests works as expected
+        This test intended to avoid some checks in other tests
+        """
+        console.terse("{0}\n".format(self.testMinionContextSetup.__doc__))
+
+        act = self.addEnterDeed("TestOptsSetupMinion")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "TestOptsSetupMinion")
+        act = self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "SaltRaetManorLaneSetup")
+        act = self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "SaltRaetRoadStackSetup")
+        act = self.addEnterDeed("StatsMinionTestSetup")
+        self.assertIn(act, self.frame.enacts)
+        self.assertEqual(act.actor, "StatsMinionTestSetup")
+
+        act = self.addRecurDeed("SaltRaetStatsEventer")
+        self.assertIn(act, self.frame.reacts)
+        self.assertEqual(act.actor, "SaltRaetStatsEventer")
+
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+
+        self.frame.enter()
+        self.assertDictEqual(act.actor.Ioinits,
+                             {'opts': '.salt.opts',
+                              'stats_req': '.salt.stats.event_req',
+                              'lane_stack': '.salt.lane.manor.stack',
+                              'road_stack': '.salt.road.manor.stack'})
+
+        self.assertTrue(hasattr(act.actor, 'opts'))
+        self.assertTrue(hasattr(act.actor, 'stats_req'))
+        self.assertTrue(hasattr(act.actor, 'lane_stack'))
+        self.assertTrue(hasattr(act.actor, 'road_stack'))
+        self.assertIsInstance(act.actor.lane_stack.value, LaneStack)
+        self.assertIsInstance(act.actor.road_stack.value, RoadStack)
+        self.frame.recur()
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionRoadStats(self):
+        """
+        Test Minion Road Stats request (A1)
+        """
+        console.terse("{0}\n".format(self.testMinionRoadStats.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMinion")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMinionTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMinion")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats = odict({'test_stats_event': 111})
+        laneStack.value.stats = odict()
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.road.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('road', 'stats')
+        minionName = roadStack.value.local.name
+        masterName = testStack.local.name
+        # road stats request
+        statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
+                                   'src': (masterName, None, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 1)
+
+        msg, sender = testStack.rxMsgs.popleft()
+        self.assertDictEqual(msg, {u'route': {u'src': [ns2u(minionName), u'manor', None],
+                                              u'dst': [ns2u(masterName), None, u'event_fire']},
+                                   u'tag': ns2u(tag),
+                                   u'data': {u'test_stats_event': 111}})
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionLaneStats(self):
+        """
+        Test Minion Road Stats request (A2)
+        """
+        console.terse("{0}\n".format(self.testMinionLaneStats.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMinion")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMinionTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMinion")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats = odict()
+        laneStack.value.stats = odict({'test_stats_event': 111})
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {})
+        self.assertDictEqual(laneStack.value.stats, {'test_stats_event': 111})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.road.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('lane', 'stats')
+        minionName = roadStack.value.local.name
+        masterName = testStack.local.name
+        # lane stats request
+        statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
+                                   'src': (masterName, None, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 1)
+
+        msg, sender = testStack.rxMsgs.popleft()
+        self.assertDictEqual(msg, {u'route': {u'src': [ns2u(minionName), u'manor', None],
+                                              u'dst': [ns2u(masterName), None, u'event_fire']},
+                                   u'tag': ns2u(tag),
+                                   u'data': {u'test_stats_event': 111}})
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionStatsWrongMissingTag(self):
+        """
+        Test Minion Stats requests with unknown and missing tag (A3, A4)
+        """
+        console.terse("{0}\n".format(self.testMinionStatsWrongMissingTag.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMinion")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMinionTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMinion")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats = odict({'test_road_stats_event': 111})
+        laneStack.value.stats = odict({'test_lane_stats_event': 222})
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.road.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = 'salt/unknown/tag'
+        self.assertNotEqual(tag, tagify('lane', 'stats'))
+        self.assertNotEqual(tag, tagify('road', 'stats'))
+        minionName = roadStack.value.local.name
+        masterName = testStack.local.name
+        # unknown tag in stats request
+        statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
+                                   'src': (masterName, None, None)},
+                         'tag': tag})
+        # no tag in stats request
+        statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
+                                   'src': (masterName, None, None)}})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionStatsUnknownRemote(self):
+        """
+        Test Minion Stats request with unknown remote (B1)
+        """
+        console.terse("{0}\n".format(self.testMinionStatsUnknownRemote.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMinion")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMinionTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMinion")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats = odict({'test_road_stats_event': 111})
+        laneStack.value.stats = odict({'test_lane_stats_event': 222})
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.road.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        tag = tagify('road', 'stats')
+        minionName = roadStack.value.local.name
+        # unknown remote (src) name in stats request
+        unknownName = 'unknownName'
+        statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
+                                   'src': (unknownName, None, None)},
+                         'tag': tag})
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+
+    def testMinionStatsNoRequest(self):
+        """
+        Test Minion Stats no requests (nothing to do) (B2)
+        """
+        console.terse("{0}\n".format(self.testMinionStatsNoRequest.__doc__))
+
+        # Bootstrap
+        self.addEnterDeed("TestOptsSetupMinion")
+        self.addEnterDeed("SaltRaetManorLaneSetup")
+        self.addEnterDeed("SaltRaetRoadStackSetup")
+        self.addEnterDeed("StatsMinionTestSetup")
+        act = self.addRecurDeed("SaltRaetStatsEventerMinion")
+        self.resolve()  # resolve House, Framer, Frame, Acts, Actors
+        self.frame.enter()
+
+        # Prepare
+        # add a test stat key-value
+        roadStack = self.store.fetch('.salt.road.manor.stack')
+        laneStack = self.store.fetch('.salt.lane.manor.stack')
+        roadStack.value.stats = odict({'test_road_stats_event': 111})
+        laneStack.value.stats = odict({'test_lane_stats_event': 222})
+        # ensure stats are equal to expected
+        self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
+        self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
+        # clear lane stack remotes
+
+        # add stats request
+        testStack = self.store.fetch('.salt.test.road.stack').value
+        statsReq = self.store.fetch('.salt.stats.event_req').value
+        # no request
+        self.assertEqual(len(statsReq), 0)
+
+        # Test
+        self.frame.recur()  # run in frame
+
+        # Check
+        self.assertEqual(len(testStack.rxMsgs), 0)
+        testStack.serviceAll()
+        self.assertEqual(len(testStack.rxMsgs), 0)
+
+        # Close active stacks servers
+        act.actor.lane_stack.value.server.close()
+        act.actor.road_stack.value.server.close()
+        testStack = self.store.fetch('.salt.test.road.stack')
+        if testStack:
+            testStack.value.server.close()
+
+def runOne(test):
+    '''
+    Unittest Runner
+    '''
+    test = StatsEventerTestCase(test)
+    suite = unittest.TestSuite([test])
+    unittest.TextTestRunner(verbosity=2).run(suite)
+
+
+def runSome():
+    """ Unittest runner """
+    tests = []
+    names = [
+        'testMasterContextSetup',
+        'testMasterRoadStats',
+        'testMasterLaneStats',
+        'testMasterStatsWrongMissingTag',
+        'testMasterStatsUnknownRemote',
+        'testMasterStatsNoRequest',
+        'testMinionContextSetup',
+        'testMinionRoadStats',
+        'testMinionLaneStats',
+        'testMinionStatsWrongMissingTag',
+        'testMinionStatsUnknownRemote',
+        'testMinionStatsNoRequest',
+        ]
+    tests.extend(map(StatsEventerTestCase, names))
+    suite = unittest.TestSuite(tests)
+    unittest.TextTestRunner(verbosity=2).run(suite)
+
+
+def runAll():
+    """ Unittest runner """
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(StatsEventerTestCase))
+    unittest.TextTestRunner(verbosity=2).run(suite)
+
+
+if __name__ == '__main__' and __package__ is None:
+
+    # console.reinit(verbosity=console.Wordage.concise)
+
+    runAll()  # run all unittests
+
+    # runSome()  #only run some
+
+    # runOne('testMasterContextSetup')