def test_set_variable(self): def func1(_: '#x') -> '#y': return 2 def func2(_: '#x') -> '#z': return 3 startup = Startup() startup.set('#x', 1) self.assertDictEqual({'#x': 1}, startup.call()) # Call Startup.set() before registering functions. startup = Startup() startup.set('#x', 1) startup.set('#z', 0) startup(func1) startup(func2) self.assertDictEqual({'#x': 1, '#y': 2, '#z': 3}, startup.call()) # Call Startup.set() after registering functions. startup = Startup() startup(func1) startup(func2) startup.set('#x', 1) startup.set('#z', 0) self.assertDictEqual({'#x': 1, '#y': 2, '#z': 3}, startup.call()) # Overwrite Startup.set(). startup = Startup() startup.set('x', 1) self.assertDictEqual({'x': 2}, startup.call(x=2)) with self.assertRaises(StartupError): startup.set('v', 1)
def test_join(self): startup = Startup() data = [] @startup def func2() -> 'x': data.append(2) return 2 @startup def func1() -> 'x': data.append(1) return 1 @startup def func3() -> 'x': data.append(3) return 3 @startup def func_join_1(x: ['x']): self.assertEqual([1, 2, 3], x) data.append('join') self.assertEqual({'x': 3}, startup.call()) self.assertEqual([1, 2, 3, 'join'], data)
def test_class_and_method(self): startup = Startup() @startup.with_annotations({'return': 'foo'}) class Foo: def __init__(self): pass @startup.with_annotations({'return': 'bar'}) class Bar: @classmethod def c(cls): return 'c' def m(self): return 'm' self.assertListEqual(['self'], inspect.getfullargspec(Foo).args) self.assertListEqual([], inspect.getfullargspec(Bar).args) self.assertListEqual(['cls'], inspect.getfullargspec(Bar.c).args) self.assertTrue(inspect.ismethod(Bar.c)) self.assertListEqual(['self'], inspect.getfullargspec(Bar().m).args) self.assertTrue(inspect.ismethod(Bar().m)) startup.add_func(Bar.c, {'return': 'c'}) startup.add_func(Bar().m, {'return': 'm'}) variables = startup.call() self.assertTrue(isinstance(variables['foo'], Foo)) self.assertTrue(isinstance(variables['bar'], Bar)) self.assertEqual('c', variables['c']) self.assertTrue('m', variables['m'])
def test_multiple_return_1(self): startup = Startup() data = [] @startup def func() -> ('x', 'y', 'z'): return 'x-str', 'y-str', 'z-str' @startup def func_z(z: 'z'): self.assertEqual('z-str', z) data.append('z') @startup def func_x(x: 'x'): self.assertEqual('x-str', x) data.append('x') @startup def func_y(y: 'y'): self.assertEqual('y-str', y) data.append('y') self.assertEqual({ 'x': 'x-str', 'y': 'y-str', 'z': 'z-str' }, startup.call()) self.assertEqual(['x', 'y', 'z'], data)
def test_with_annotations(self): startup = Startup() @startup.with_annotations({'a': 'a', 'b': 'b', 'return': 'c'}) def func(a, b): return (a, b) self.assertDictEqual({ 'a': 1, 'b': 2, 'c': (1, 2) }, startup.call(a=1, b=2))
def test_multiple_return_2(self): startup = Startup() @startup def func_repeat() -> ('x', 'x', 'x'): return 1, 3, 2 @startup def func_collect(xs: ['x']) -> 'xs': return xs self.assertEqual({'xs': [1, 3, 2], 'x': 2}, startup.call())
def test_sequential_order(self): startup = Startup() data = [] @startup def func3(x: 'x') -> 'y': data.append(x) return x - 1 @startup def func2(y: 'y') -> 'z': data.append(y) return y - 1 @startup def func1(z: 'z'): data.append(z) self.assertEqual({'x': 3, 'y': 2, 'z': 1}, startup.call(x=3)) self.assertEqual([3, 2, 1], data)
def test_lexicographical_order(self): startup = Startup() data = [] @startup def func2(): data.append(2) @startup def func1(): data.append(1) @startup def func3(): data.append(3) self.assertEqual({}, startup.call()) self.assertEqual([1, 2, 3], data) # You cannot call run() again, by the way. self.assertRaises(StartupError, startup.call)