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:
