def test_ordering_runners(self): m = Mock() class Type(): pass @requires(first()) def f_none(): m.f_none() def n_none(): m.n_none() def l_none(): m.l_none() def make_t(): return Type() @requires(first(Type)) def f_t(t): m.f_t() @requires(Type) def n_t(t): m.n_t() @requires(last(Type)) def l_t(t): m.l_t() runner = Runner() runner.add(l_none, last()) runner.add(f_t) Runner(Runner(l_t, n_t), runner, Runner(f_none, n_none), Runner(make_t))() compare([ call.f_none(), call.n_none(), call.l_none(), call.f_t(), call.n_t(), call.l_t(), ], m.mock_calls)
def test_ordering(self): m = Mock() class Type(): pass @requires(first()) def f_none(): m.f_none() def n_none(): m.n_none() @requires(last()) def l_none(): m.l_none() def make_t(): return Type() @requires(first(Type)) def f_t(t): m.f_t() @requires(Type) def n_t(t): m.n_t() @requires(last(Type)) def l_t(t): m.l_t() Runner(l_t, n_t, l_none, f_t, f_none, n_none, make_t)() compare([ call.f_none(), call.n_none(), call.l_none(), call.f_t(), call.n_t(), call.l_t(), ], m.mock_calls)
def test_clone(self): m = Mock() class T1(object): pass class T2(object): pass def f1(): m.f1() def n1(): m.n1() return T1(), T2() def l1(): m.l1() def t1(obj): m.t1() def t2(obj): m.t2() # original runner1 = Runner() runner1.add(f1, first()) runner1.add(n1) runner1.add(l1, last()) runner1.add(t1, T1) runner1.add(t2, T2) # now clone and add bits def f2(): m.f2() def n2(): m.n2() def l2(): m.l2() def tn(obj): m.tn() runner2 = runner1.clone() runner2.add(f2, first()) runner2.add(n2) runner2.add(l2, last()) # make sure types stay in order runner2.add(tn, T2) # now run both, and make sure we only get what we should runner1() compare([ call.f1(), call.n1(), call.l1(), call.t1(), call.t2(), ], m.mock_calls) m.reset_mock() runner2() compare([ call.f1(), call.f2(), call.n1(), call.n2(), call.l1(), call.l2(), call.t1(), call.t2(), call.tn() ], m.mock_calls)
def make_runner(do): runner = Runner(ArgumentParser) runner.add(options, ArgumentParser) runner.add(parse_args, last(ArgumentParser)) runner.add(parse_config, first(Namespace)) runner.add(setup_logging, log_path = item(first(Config), 'log'), quiet = attr(first(Namespace), 'quiet'), verbose = attr(first(Namespace), 'verbose')) runner.add(DatabaseHandler, item(Config, 'db')) runner.add(do, attr(DatabaseHandler, 'conn'), attr(Namespace, 'path')) return runner
def test_after(self): m = Mock() class Type(): pass def make_t(): return Type() @requires(first(Type)) def f_t(t): m.f_t() @requires(Type) def n_t(t): m.n_t() @requires(last(Type)) def l_t_1(t): m.l_t_1() @requires(after(Type)) def after_t1(): m.after_t1() @requires(last(Type)) def l_t_2(t): m.l_t_2() Runner(make_t, l_t_1, after_t1, l_t_2, n_t, f_t)() compare([ call.f_t(), call.n_t(), call.l_t_1(), call.after_t1(), call.l_t_2(), ], m.mock_calls)
def test_when_how(self): w = first(attr(Type1, 'foo')) compare(repr(w), 'first(Type1.foo)') self.assertTrue(isinstance(w, when)) h = w.type compare(h.type, Type1) compare(h.names, ('foo', )) self.assertTrue(isinstance(h, how))
def test_how_when(self): h = attr(first(Type1), 'foo') compare(repr(h), 'first(Type1).foo') compare(h.names, ('foo',), ) self.assertTrue(isinstance(h, how)) w = h.type self.assertTrue(isinstance(w, when)) compare(w.type, Type1)
def test_how_when(self): m = Mock() class T(dict): foo = 'bar' @requires(item(first(T), 'baz')) def f_t(o): m.f_t(o) @requires(T) def n_t(o): m.n_t(o.__class__) @requires(attr(last(T), 'foo')) def l_t(o): m.l_t(o) def make_t(): t = T() t['baz'] = 'bob' return t Runner(l_t, n_t, f_t, make_t)() compare([ call.f_t('bob'), call.n_t(T), call.l_t('bar'), ], m.mock_calls)
def test_first(self): f = first(Type1) compare(repr(f), 'first(Type1)') compare(f.type, Type1) self.assertTrue(isinstance(f, when))
@requires(ArgumentParser) def base_options(parser): parser.add_argument('config', help='Path to .ini file') parser.add_argument('--quiet', action='store_true', help='Log less to the console') parser.add_argument('--verbose', action='store_true', help='Log more to the console') @requires(last(ArgumentParser)) def parse_args(parser): return parser.parse_args() class Config(dict): pass @requires(first(Namespace)) def parse_config(args): config = RawConfigParser(dict_type=Config) config.read(args.config) return Config(config.items('main')) def setup_logging(log_path, quiet=False, verbose=False): handler = logging.FileHandler(log_path) handler.setLevel(logging.DEBUG) log.addHandler(handler) if not quiet: handler = logging.StreamHandler(sys.stderr) handler.setLevel(logging.DEBUG if verbose else logging.INFO) log.addHandler(handler) class DatabaseHandler: