added unittests and improved code.

calculate.py

@@ -1,4 +1,3 @@
-import pydux_thunk
 import asyncio
 
 initial_state = {
@@ -15,7 +14,6 @@ class ActionTypes(object):
 
 
 class ActionCreators(object):
-
     @staticmethod
     def calculate(value1, value2):
         return thunk(value1, value2)
@@ -82,25 +80,42 @@ def thunk(value1, value2):
 
 if __name__ == '__main__':
     import unittest
-
+    import unittest.mock as mock
+    import inspect
+    loop = asyncio.get_event_loop()
 
     class TestSuite(unittest.TestCase):
         def test_action_creators(self):
-            # self.assertEqual(ActionCreators.calculate(1, 2), thunk(1, 2))
+            received = ActionCreators.calculate(1, 2)
+            expected = thunk(1, 2)
+            self.assertEqual(expected.__code__, received.__code__)
             self.assertEqual(ActionCreators.start(), {'type': 'calculate/START'})
             self.assertEqual(ActionCreators.success(4), {'type': 'calculate/SUCCESS', 'result': 4})
-
-        # self.assertEqual(ActionCreators.failure(ZeroDivisionError()), {'type': 'calculate/FAILURE', 'error': ZeroDivisionError()})
+            self.assertEqual(ActionCreators.failure(ZeroDivisionError().__class__), {'type': 'calculate/FAILURE', 'error': ZeroDivisionError().__class__})
 
         def test_reducer(self):
-            self.assertEqual(reducer(None, ActionCreators.calculate(2)),
-							 {'running': False, 'result': None, 'error': None})
-
-        # self.assertEqual(reducer(452, ActionCreators.set_state(13)), 13)
-        # self.assertEqual(reducer(None, ActionCreators.increment()), 1)
-        # self.assertEqual(reducer(341, ActionCreators.increment()), 342)
-        # self.assertEqual(reducer(None, ActionCreators.decrement()), -1)
-        # self.assertEqual(reducer(251, ActionCreators.decrement()), 250)
+            self.assertEqual(reducer(None, None), initial_state)
+            self.assertEqual(reducer(initial_state, None), initial_state)
+            self.assertEqual(reducer(initial_state, {'type': ActionCreators.calculate(1, 2)}), initial_state)
+
+            self.assertEqual(reducer(initial_state, ActionCreators.start()), {'running': True, 'result': None, 'error': None})
+            self.assertEqual(reducer(initial_state, ActionCreators.success(7)), {'running': False, 'result': 7, 'error': None})
+            self.assertEqual(reducer(initial_state, ActionCreators.failure(ZeroDivisionError.__class__)), {'running': False, 'result': None, 'error': ZeroDivisionError.__class__})
+
+        def test_thunk(self):
+            dispatched_actions = []
+
+            def dispatch(action):
+                dispatched_actions.append(action)
+
+            def get_state():
+                pass
+
+            wrapper = thunk(3, 7)
+            self.assertTrue(inspect.iscoroutinefunction(wrapper))
+            task = wrapper(dispatch, get_state)
+            loop.run_until_complete(task)
+            self.assertEqual(dispatched_actions, [{'type': 'calculate/START'}, {'type': 'calculate/SUCCESS', 'result': 3/7}])
 
 
     unittest.main()

counter.py

@@ -1,55 +1,66 @@
 initial_state = 0
 
+
 class ActionTypes(object):
-	SET_STATE = 'counter/SET_STATE'
-	INCREMENT = 'counter/INCREMENT'
-	DECREMENT = 'counter/DECREMENT'
+    SET_STATE = 'counter/SET_STATE'
+    INCREMENT = 'counter/INCREMENT'
+    DECREMENT = 'counter/DECREMENT'
+
 
 class ActionCreators(object):
-	def set_state(value):
-		return dict(
-			type=ActionTypes.SET_STATE,
-			value=value
-		)
-
-	def increment():
-		return dict(
-			type=ActionTypes.INCREMENT
-		)
-
-	def decrement():
-		return dict(
-			type=ActionTypes.DECREMENT
-		)
-
-def reducer (state=None, action=None):
-	if state is None:
-		state = initial_state
-	if not (isinstance(action, dict) and 'type' in action):
-		return state
-	if action['type'] == ActionTypes.SET_STATE:
-		state = action['value'] 
-	elif action['type'] == ActionTypes.INCREMENT:
-		state = state + 1
-	elif action['type'] == ActionTypes.DECREMENT:
-		state = state - 1
-	return state
+    @staticmethod
+    def set_state(value):
+        return dict(
+            type=ActionTypes.SET_STATE,
+            value=value
+        )
+
+    @staticmethod
+    def increment():
+        return dict(
+            type=ActionTypes.INCREMENT
+        )
+
+    @staticmethod
+    def decrement():
+        return dict(
+            type=ActionTypes.DECREMENT
+        )
+
+
+def reducer(state=None, action=None):
+    if state is None:
+        state = initial_state
+    if not (isinstance(action, dict) and 'type' in action):
+        return state
+    if action['type'] == ActionTypes.SET_STATE:
+        state = action['value']
+    elif action['type'] == ActionTypes.INCREMENT:
+        state += 1
+    elif action['type'] == ActionTypes.DECREMENT:
+        state -= 1
+    return state
+
 
 if __name__ == '__main__':
-	import unittest
-
-	class TestSuite(unittest.TestCase):
-		def test_action_creators(self):
-			self.assertEqual(ActionCreators.set_state(12), {'type': 'counter/SET_STATE', 'value': 12})
-			self.assertEqual(ActionCreators.increment(), {'type': 'counter/INCREMENT'})
-			self.assertEqual(ActionCreators.decrement(), {'type': 'counter/DECREMENT'})
-
-		def test_reducer(self):
-			self.assertEqual(reducer(None, ActionCreators.set_state(13)), 13)
-			self.assertEqual(reducer(452, ActionCreators.set_state(13)), 13)
-			self.assertEqual(reducer(None, ActionCreators.increment()), 1)
-			self.assertEqual(reducer(341, ActionCreators.increment()), 342)
-			self.assertEqual(reducer(None, ActionCreators.decrement()), -1)
-			self.assertEqual(reducer(251, ActionCreators.decrement()), 250)
-
-	unittest.main()
+    import unittest
+
+
+    class TestSuite(unittest.TestCase):
+        def test_action_creators(self):
+            self.assertEqual(ActionCreators.set_state(12), {'type': 'counter/SET_STATE', 'value': 12})
+            self.assertEqual(ActionCreators.increment(), {'type': 'counter/INCREMENT'})
+            self.assertEqual(ActionCreators.decrement(), {'type': 'counter/DECREMENT'})
+
+        def test_reducer(self):
+            self.assertEqual(reducer(67, None), 67)
+            self.assertEqual(reducer(None, None), 0)
+            self.assertEqual(reducer(None, ActionCreators.set_state(13)), 13)
+            self.assertEqual(reducer(452, ActionCreators.set_state(13)), 13)
+            self.assertEqual(reducer(None, ActionCreators.increment()), 1)
+            self.assertEqual(reducer(341, ActionCreators.increment()), 342)
+            self.assertEqual(reducer(None, ActionCreators.decrement()), -1)
+            self.assertEqual(reducer(251, ActionCreators.decrement()), 250)
+
+
+    unittest.main()

project.py

@@ -13,6 +13,8 @@ import calculate
 loop = asyncio.get_event_loop()
 pydux_thunk.loop = loop
 
+pydux_sqlite.thread.start()
+
 # Combine the middleware
 middleware = [
     pydux_thunk.middleware,
@@ -60,3 +62,4 @@ store.dispatch(counter.ActionCreators.increment())
 store.dispatch(counter.ActionCreators.increment())
 store.dispatch(counter.ActionCreators.increment())
 loop.run_forever()
+pydux_sqlite.thread.join()

pydux_sqlite.py

@@ -1,6 +1,6 @@
 import sqlite3
 import json
-import datetime, time
+import datetime
 import threading
 import queue
 
@@ -9,16 +9,20 @@ db_path = 'state.db'
 
 
 def sql_thread(command_queue, response_queue):
-    connection = sqlite3.connect(db_path)
-    cursor = connection.cursor()
-    cursor.execute('CREATE TABLE IF NOT EXISTS actions (id INTEGER PRIMARY KEY, date TEXT, action TEXT)')
-    cursor.execute('CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY, date TEXT, state TEXT)')
-    connection.commit()
     task_done = False
 
+    try:
+        connection = sqlite3.connect(db_path)
+        cursor = connection.cursor()
+        cursor.execute('CREATE TABLE IF NOT EXISTS actions (id INTEGER PRIMARY KEY, date TEXT, action TEXT)')
+        cursor.execute('CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY, date TEXT, state TEXT)')
+        connection.commit()
+    except Exception as error:
+        response_queue.put(error)
+
     while not task_done:
-        table, data = command_queue.get()
         try:
+            table, data = command_queue.get()
             if table == 'actions':
                 cursor.execute('INSERT INTO actions VALUES (NULL, ?, ?)', data)
                 connection.commit()
@@ -36,8 +40,7 @@ def sql_thread(command_queue, response_queue):
 
 command_queue = queue.Queue()
 response_queue = queue.Queue()
-t = threading.Thread(target=sql_thread, args=(command_queue, response_queue))
-t.start()
+thread = threading.Thread(target=sql_thread, args=(command_queue, response_queue))
 
 
 def middleware(store):
@@ -54,3 +57,37 @@ def middleware(store):
 
         return update_db
     return wrapper
+
+if __name__ == "__main__":
+    import unittest
+
+    class TestSQLite(unittest.TestCase):
+        def setUp(self):
+            db_path = 'test_state.db'
+            self.command_queue = queue.Queue()
+            self.response_queue = queue.Queue()
+            self.test_thread = threading.Thread(target=sql_thread, args=(command_queue, response_queue))
+            self.test_thread.start()
+
+        def tearDown(self):
+            command_queue.put(('DONE', None))
+            self.test_thread.join()
+
+        def test_middleware(self):
+            store = {
+                'dispatch': lambda state, action: state,
+                'get_state': lambda: {}
+            }
+            wrapper = middleware(store)
+            self.assertTrue(callable(wrapper))
+            update_fn = wrapper(lambda action: None)
+            self.assertTrue(callable(update_fn))
+            action = {'type': 'module/ACTION', 'value': 5}
+            state = {}
+            update_fn(action)
+            action_table = command_queue.get()
+            state_table = command_queue.get()
+            self.assertEqual(action_table, ('actions', [datetime.datetime.now(), json.dumps(action)]))
+            self.assertEqual(state_table, ('state', [datetime.datetime.now(), json.dumps(state)]))
+
+    unittest.main()

requirements.txt

@@ -1,2 +1,3 @@
 pydux
-janus
+janus
+mock