tests/test.py

   1 #! /usr/bin/env python
   2
   3 import unittest2 as unittest
   4 import digraphtools
   5 import digraphtools.topsort as topsort
   6
   7 import core.bits as bits
   8 import core.deptools as deptools
   9 import core.store
  10
  11 class BitTests(unittest.TestCase):
  12         def testTask(self):
  13                 task = bits.Task(tuple(), None, bits.TaskComplete(['fnord']))
  14                 task = bits.Task(('fish','heads'), None, bits.TaskComplete(['fnord']))
  15
  16 class GraphStrategyTests(unittest.TestCase):
  17         def setUp(self):
  18                 class C(bits.Item): pass
  19                 class B(bits.Item): depends = (C,)
  20                 class A(bits.Item): depends = (B,C)
  21                 self.A,self.B,self.C = A,B,C
  22         def test_get_graph(self):
  23                 A,B,C = self.A,self.B,self.C
  24                 g = deptools.GraphDependencyStrategy.get_graph(A)
  25                 ref = [A,[ [B,[ [C, []] ]], [C, []] ]]  # Reasons to not use this representation
  26                 self.assertEqual(g,ref)
  27         def test_iterate_item_dependencies(self):
  28                 toporder = deptools.GraphDependencyStrategy.iterate_item_dependencies(self.A)
  29                 self.assertEqual(list(toporder), [self.C,self.B,self.A])
  30         def test_item_factory(self):
  31                 a = deptools.GraphDependencyStrategy.item_factory(self.A)
  32                 self.assertIsInstance(a, self.A)
  33                 clstoporder = deptools.GraphDependencyStrategy.iterate_item_dependencies(self.A)
  34                 insttoporder = deptools.GraphDependencyStrategy.iterate_item_dependencies(a)
  35                 for cls,inst in zip(clstoporder,insttoporder):
  36                         self.assertIsInstance(inst,cls)
  37
  38 class DigraphStrategyTests(unittest.TestCase):
  39         def setUp(self):
  40                 class C(bits.Item): pass
  41                 class B(bits.Item): depends = (C,)
  42                 class A(bits.Item): depends = (B,C)
  43                 self.A,self.B,self.C = A,B,C
  44         def test_iterate_item_dependencies(self):
  45                 toporder = deptools.DigraphDependencyStrategy.iterate_item_dependencies(self.A)
  46                 self.assertEqual(list(toporder), [self.C,self.B,self.A])
  47         def test_item_factory(self):
  48                 a = deptools.DigraphDependencyStrategy.item_factory(self.A)
  49                 self.assertIsInstance(a, self.A)
  50                 clstoporder = deptools.DigraphDependencyStrategy.iterate_item_dependencies(self.A)
  51                 insttoporder = deptools.DigraphDependencyStrategy.iterate_item_dependencies(a)
  52                 for cls,inst in zip(clstoporder,insttoporder):
  53                         self.assertIsInstance(inst,cls)
  54         def test_find_goal_nodes(self):
  55                 goals = deptools.DigraphDependencyStrategy.find_goal_nodes([self.A,self.B,self.C])
  56                 self.assertEqual(set([self.A]), goals)
  57
  58 class SimpleStrategyTests(unittest.TestCase):
  59         def setUp(self):
  60                 class C(bits.Item): pass
  61                 class B(bits.Item): depends = (C,)
  62                 class A(bits.Item): depends = (B,C)
  63                 self.A,self.B,self.C = A,B,C
  64         def test_iterate_item_dependencies(self):
  65                 toporder = deptools.SimpleDependencyStrategy.iterate_item_dependencies(self.A)
  66                 self.assertEqual(list(toporder), [self.C,self.B,self.A])
  67
  68 class TopsortTests(unittest.TestCase):
  69         def test_vr_topsort(self):
  70                 n = 5
  71                 partial_order = [(1,2), (2,3), (1,5)]
  72                 g = digraphtools.graph_from_edges(digraphtools.from_partial_order(partial_order))
  73                 grid = topsort.partial_order_to_grid(partial_order,n)
  74                 for le in topsort.vr_topsort(n,grid):
  75                         digraphtools.verify_partial_order(digraphtools.iter_partial_order(g), le)
  76
  77 class StoreTests(unittest.TestCase):
  78         sample_json = '[{"name": "wake_up"}, {"depends": ["wake_up"], "name": "get_up"}, {"depends": ["get_up"], "name": "make_coffee"}, {"depends": ["make_coffee"], "name": "drink_coffee"}, {"depends": ["get_up"], "name": "make_breakfast"}, {"depends": ["make_breakfast"], "name": "eat_breakfast"}, {"depends": ["get_up", "eat_breakfast", "make_coffee"], "name": "walk_out_door"}, {"depends": ["walk_out_door", "eat_breakfast", "drink_coffee"], "name": "go_to_work", "description": "Leave to go to work"}]'
  79         def _dont_test_memorystore(self):
  80                 uuid = '123456'
  81                 ms = core.store.MemoryStore()
  82                 self.assertFalse(ms.exists(uuid))
  83                 self.assertFalse(ms.exists(uuid, 'items'))
  84                 ms.new_task(uuid)
  85                 self.assertTrue(ms.exists(uuid))
  86                 self.assertFalse(ms.exists(uuid, 'items'))
  87                 ms.store(uuid, 'items', self.sample_json)
  88                 self.assertEqual(ms.retrieve(uuid, 'items'), self.sample_json)
  89
  90 if __name__ == '__main__':
  91         unittest.main()