1# -*- coding: utf-8 -*-
2"""
3Unit Test Template
4"""
5
6import sys
7if sys.version_info < (2, 7):
8    import unittest2 as unittest
9else:
10    import unittest
11
12import os
13
14from ioflo.test import testing
15from ioflo.aid.consoling import getConsole
16console = getConsole()
17
18
19from ioflo.base import acting
20from ioflo.base import doing
21from ioflo.base import storing
22
23
24def setUpModule():
25    console.reinit(verbosity=console.Wordage.concise)
26
27def tearDownModule():
28    pass
29
30
31class BasicTestCase(testing.FrameIofloTestCase):
32    """
33    Example TestCase
34    """
35
36    def setUp(self):
37        """
38        Call super if override so House Framer and Frame are setup correctly
39        """
40        super(BasicTestCase, self).setUp()
41
42    def tearDown(self):
43        """
44        Call super if override so House Framer and Frame are torn down correctly
45        """
46        super(BasicTestCase, self).tearDown()
47
48    def testActify(self):
49        """
50        Test the actify decorator
51        """
52        console.terse("{0}\n".format(self.testActify.__doc__))
53        @acting.actify("BlueBeard")
54        def bearded(self, x=1, y=2):
55            """
56            Actor action method
57            """
58            z = x +  y
59            return (self, z)
60
61        self.assertIn("BlueBeard", acting.Actor.Registry)
62        actor, inits, ioinits, parms = acting.Actor.__fetch__("BlueBeard")
63        self.assertIs(actor._Parametric, True)
64        self.assertDictEqual(actor.Inits, {})
65        self.assertDictEqual(actor.Ioinits, {})
66        self.assertDictEqual(actor.Parms, {})
67        self.assertDictEqual(inits, {})
68        self.assertDictEqual(ioinits, {})
69        self.assertDictEqual(parms, {})
70
71        actor = actor()  # create instance
72        self.assertIsInstance(actor, acting.Actor )
73        self.assertEqual(actor.__class__.__name__, "BlueBeard")
74
75        self.assertEqual(actor.action.__self__.__class__.__name__, "BlueBeard")
76        self.assertIs(actor.action.__func__, bearded)
77        self.assertIs(actor.action.__self__, actor)
78
79        self.assertEqual(actor.action.__doc__, '\n            Actor action method\n            ')
80        self.assertEqual(actor.action.__name__, 'bearded')
81
82        me, z = actor()  # perform action
83        self.assertIs(me, actor)
84        self.assertEqual(z, 3)
85
86
87    def testDoify(self):
88        """
89        Test the doify decorator
90        """
91        console.terse("{0}\n".format(self.testDoify.__doc__))
92        @doing.doify("BlackSmith")
93        def blackened(self, x=3, y=2):
94            """
95            Doer action method
96            """
97            z = x + y
98            return (self, z)
99
100        self.assertIn("BlackSmith", doing.Doer.Registry)
101        actor, inits, ioinits, parms = doing.Doer.__fetch__("BlackSmith")
102        self.assertIs(actor._Parametric, False)
103        self.assertDictEqual(actor.Inits, {})
104        self.assertDictEqual(actor.Ioinits, {})
105        self.assertDictEqual(actor.Parms, {})
106        self.assertDictEqual(inits, {})
107        self.assertDictEqual(ioinits, {})
108        self.assertDictEqual(parms, {})
109
110        actor = actor()  # create instance
111        self.assertIsInstance(actor, doing.Doer )
112        self.assertEqual(actor.__class__.__name__, "BlackSmith")
113
114        self.assertEqual(actor.action.__self__.__class__.__name__, "BlackSmith")
115        self.assertIs(actor.action.__func__, blackened)
116        self.assertIs(actor.action.__self__, actor)
117
118        self.assertEqual(actor.action.__doc__, '\n            Doer action method\n            ')
119        self.assertEqual(actor.action.__name__, 'blackened')
120
121        me, z = actor()  # perform action
122        self.assertIs(me, actor)
123        self.assertEqual(z, 5)
124
125    def testFrameDoer(self):
126        """
127        Test adding a Doer to a frame and running it
128        """
129        console.terse("{0}\n".format(self.testFrameDoer.__doc__))
130        @doing.doify("TestDoer")
131        def action(self, a="Felgercarb", **kwa):
132            """
133            Doer action method
134            """
135            share = self.store.create(".test.a").update(value=a)
136
137        self.assertIn("TestDoer", doing.Doer.Registry)
138        act = self.addDoer("TestDoer")
139        self.assertIsInstance(act, acting.Act)
140        self.assertIn(act, self.frame.reacts)
141        self.assertEqual(act.actor, "TestDoer")
142        self.assertEqual(act.frame, self.frame.name)
143
144        self.resolve()  # resolve House
145        self.assertIs(act.frame, self.frame)
146        self.assertIs(act.frame.framer, self.framer)
147        self.assertIs(act.actor.store, self.store)
148        self.assertIn(act.actor.name, doing.Doer.Registry)
149        self.assertEqual(act.actor.name, "TestDoer")
150        self.assertIsInstance(act.actor, doing.Doer)
151        self.assertEqual(act.actor.__class__.__name__, "TestDoer")
152
153        self.assertEqual(act.actor.action.__self__.__class__.__name__, "TestDoer")
154        self.assertIs(act.actor.action.__func__, action)
155        self.assertIs(act.actor.action.__self__, act.actor)
156
157        self.assertEqual(act.actor.action.__doc__, '\n            Doer action method\n            ')
158        self.assertEqual(act.actor.action.__name__, 'action')
159
160        self.assertIs(self.store.fetch(".test.a"), None)
161        self.frame.recur()  # run reacts in frame
162        share = self.store.fetch(".test.a")
163        self.assertIsInstance(share, storing.Share )
164        self.assertEqual(share.value, "Felgercarb")
165
166
167def runOne(test):
168    '''
169    Unittest Runner
170    '''
171    test = BasicTestCase(test)
172    suite = unittest.TestSuite([test])
173    unittest.TextTestRunner(verbosity=2).run(suite)
174
175def runSome():
176    """ Unittest runner """
177    tests =  []
178    names = ['testActify',
179             'testDoify',
180             'testFrameDoer', ]
181    tests.extend(map(BasicTestCase, names))
182    suite = unittest.TestSuite(tests)
183    unittest.TextTestRunner(verbosity=2).run(suite)
184
185def runAll():
186    """ Unittest runner """
187    suite = unittest.TestSuite()
188    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(BasicTestCase))
189    unittest.TextTestRunner(verbosity=2).run(suite)
190
191if __name__ == '__main__' and __package__ is None:
192
193    #console.reinit(verbosity=console.Wordage.concise)
194
195    #runAll() #run all unittests
196
197    runSome()#only run some
198
199    #runOne('testBasic')
200
201
202