def test_not_synthed(): @t.synth() def synth(task): task.synth(t.tmpfname()) t.raises(t.FileSynthError, t.app.run, None, ["synth"])
def test_exp_02(): with mock.patch.object(SyncthingClient, 'request') as mock_response: code = 500 msg = 'Error occured' mock_response.side_effect = PySyncthingError(code=code, message=msg) api = SyncthingClient(TOKEN, BASE_URL) t.raises(PySyncthingError, api.get_version)
def test_counter_eq_derive(): """Test parsing of counters when expecting derives and vice versa""" def run_parse(parse_func): def wrapped(data): return list(parse_func(data)) return wrapped types = "false_counter value:COUNTER:U:U\nfalse_derive value:DERIVE:U:U\n" with t.unlinking(t.temp_file(TYPESDB + types)) as path: parser = bucky.collectd.CollectDParser(types_dbs=[path]) for pkts_file in ('collectd-counter.pkts', 'collectd-derive.pkts'): for data in pkts(pkts_file): t.not_raises(ProtocolError, run_parse(parser.parse), data) for pkts_file in ('collectd-false-counter.pkts', 'collectd-false-derive.pkts'): for data in pkts(pkts_file): t.raises(ProtocolError, run_parse(parser.parse), data) parser = bucky.collectd.CollectDParser(types_dbs=[path], counter_eq_derive=True) for pkts_file in ('collectd-counter.pkts', 'collectd-derive.pkts', 'collectd-false-counter.pkts', 'collectd-false-derive.pkts'): for data in pkts(pkts_file): t.not_raises(ProtocolError, run_parse(parser.parse), data)
def test_no_underscores(cx): def fn(obj, name): return name.strip()[:1] != "_" cx.set_access(fn) cx.add_global("foo", {"bar": "baz", "_bar": "_baz"}) t.eq(cx.execute('foo["bar"]'), "baz") t.raises(t.JSError, cx.execute, 'foo["_bar"]')
def test_005(res): r = res.get('/json', headers={'Content-Type': 'application/json'}) t.eq(r.status_int, 200) t.raises(RequestFailed, res.get, '/json', headers={'Content-Type': 'text/plain'})
def test_set_item(): fl = t.FileList("a.c", "b.c") fl[0] = "foo.py" t.eq(fl, ["foo.py", "b.c"]) def assign(): fl[1] = 2 t.raises(TypeError, assign)
def test_del_item(): fl = t.FileList("a.c", "b.c") del fl[0] t.eq(fl[0], "b.c") def rem(): del fl[2] t.raises(IndexError, rem)
def test_two_task_cycle(): t.task("foo", ["bar"])(lambda: 2) t.task("bar", ["foo"])(lambda: "hi") for task in ["foo", "bar"]: t.app.clear() t.raises(t.DependencyCycleError, t.app.run, None, [task]) t.eq(t.app._dbg, [])
def test_simple_ns(): with t.ns("rho"): @t.task def foo(): return 2 t.raises(t.TaskNotFoundError, t.app.run, None, ["foo"]) t.app.run(None, ["rho:foo"]) t.eq(t.app._dbg, [("rho:foo", 2)])
def test_date_errors(): # Disallowed by iso8601 to avoid confusion with YYMMDD t.raises(FMT_ERROR, pdate, "195406") t.raises(FMT_ERROR, pdate, "foo") t.raises(FMT_ERROR, pdate, "1954-0607") t.raises(FMT_ERROR, pdate, "195406-07") t.raises(FMT_ERROR, pdate, "1954")
def test_iter(): fl = t.FileList("a.c", "b.c", "exist*") i = iter(fl) t.eq(isinstance(i, t.FileListIter), True) t.eq(i.next(), "a.c") t.eq(isinstance(i.next(), t.path), True) t.eq(i.next(), "existing") t.raises(StopIteration, i.next)
def test_exp_01(): with mock.patch.object(SyncthingClient, 'request') as mock_response: code = 500 msg = 'Error occured' mock_response.status_int = code mock_response.body_string.return_value = msg api = SyncthingClient(TOKEN, BASE_URL) t.raises(PySyncthingError, api.get_version)
def test_exceed_time(cx): script = """ var time = function() {return (new Date()).getTime();}; var start = time(); while((time() - start) < 100000) {} """ cx.max_time(1) t.raises(SystemError, cx.execute, script)
def test_019(res): import StringIO content = StringIO.StringIO("test") t.raises(RequestFailed, res.post, '/json', payload=content, headers={'Content-Type': 'text/plain'})
def test_callable_validation(): c = config.Config() def func(a, b): pass c.set("pre_fork", func) t.eq(c.pre_fork, func) t.raises(TypeError, c.set, "pre_fork", 1) t.raises(TypeError, c.set, "pre_fork", lambda x: True)
def test_020(): u = "http://*****:*****@%s:%s/auth" % (HOST, PORT) res = Resource(u) r = res.get() t.eq(r.status_int, 200) u = "http://*****:*****@%s:%s/auth" % (HOST, PORT) res = Resource(u) t.raises(Unauthorized, res.get)
def test_ident_unknown(conn, cursor): obj = {"name": "test", "sql": "select 1 as ${'zing' | ident}"} s = t.Statement(obj) t.raises(t.RenderError, s.dbs[None].prepare, conn, {}) try: s.dbs[None].prepare(conn, {}) except t.RenderError, e: str(e) # Doesn't raise
def test_dissallow_ctor(cx): class DirtyCar(object): def __init__(self): self.zap = 2 def check(obj, name): return name != "__init__" cx.add_global("DirtyCar", DirtyCar) cx.set_access(check) t.raises(t.JSError, cx.execute, "DirtyCall();")
def test_ident_no_dbinfo(conn, cursor): info = t.dbwrapper.DB_INFO["sqlite"] try: t.dbwrapper.DB_INFO.pop("sqlite") obj = {"name": "test", "sql": "select 1 as ${foo | ident}"} s = t.Statement(obj) t.raises(KeyError, s.dbs[None].prepare, conn, {"foo": "zip"}) finally: t.dbwrapper.DB_INFO["sqlite"] = info
def test_set_callback(cx): t.eq(cx.set_access(), None) t.raises(TypeError, cx.set_access, "foo") t.raises(TypeError, cx.set_access, 1) def cb(obj, name): return True t.eq(cx.set_access(cb), None) t.eq(cx.set_access(), cb) # Check that we don't erase it. t.eq(cx.set_access(), cb)
def test_no_set_invalid(cx): def fn(obj, name): return name.strip()[:1] != "_" cx.set_access(fn) glbl = {} cx.add_global("foo", glbl) cx.execute('foo["bar"] = "baz";') t.raises(t.JSError, cx.execute, 'foo["_bar"] = "baz"') t.eq(glbl, {"bar": "baz"})
def test_str_to_list_validation(): c = config.Config() t.eq(c.forwarded_allow_ips, ["127.0.0.1"]) c.set("forwarded_allow_ips", "127.0.0.1,192.168.0.1") t.eq(c.forwarded_allow_ips, ["127.0.0.1", "192.168.0.1"]) c.set("forwarded_allow_ips", "") t.eq(c.forwarded_allow_ips, []) c.set("forwarded_allow_ips", None) t.eq(c.forwarded_allow_ips, []) t.raises(TypeError, c.set, "forwarded_allow_ips", 1)
def test_adding_more_actions(): def foo(): return 2 def bar(): return "hi" t.task("foo")(foo) t.task("foo")(bar) t.app.run(None, ["foo"]) t.eq(t.app._dbg, [("foo", 2), ("foo", "hi")]) t.raises(t.TaskNotFoundError, t.app.run, None, ["bar"])
def test_get_alias(api): addressid = 2 req = api.get_aliases(addressid) path = ENDPOINTS["aliases"]["get"]["name"] % dict(addressid=addressid) t.eq(api.response.final_url, "%s%s%s" % (BASE_URL, API_PATH, path)) t.eq(api.response.request.method, ENDPOINTS["aliases"]["get"]["method"]) t.eq(api.response.status_int, 200) t.eq(req["id"], addressid) t.eq(req["address"], "*****@*****.**") t.raises(BaruwaAPIError, api.get_aliases, 7)
def test_011(res): r = res.post('/json', payload="test", headers={'Content-Type': 'application/json'}) t.eq(r.status_int, 200) t.raises(RequestFailed, res.post, '/json', payload='test', headers={'Content-Type': 'text/plain'})
def test_access_global(rt): names = [] def fn(obj, name): names.append(name) return not name.startswith("_") glbl = {"foo": "bar", "_bin": "zingle"} cx = rt.new_context(glbl, fn) t.eq(cx.execute('foo;'), "bar") t.raises(t.JSError, cx.execute, '_bin;') t.eq(names, ["foo", "foo", "_bin"])
def test_bool_validation(): c = config.Config() t.eq(c.debug, False) c.set("debug", True) t.eq(c.debug, True) c.set("debug", "true") t.eq(c.debug, True) c.set("debug", "false") t.eq(c.debug, False) t.raises(ValueError, c.set, "debug", "zilch") t.raises(TypeError, c.set, "debug", 4)
def test_set_user_password(api): userid = 10 data = {"password1": "Hp9hzcd1grdSqtrn", "password2": "Hp9hzcd1grdSqtrn"} data2 = {"password1": "Hp9hzcd1grdSqtrn"} req = api.set_user_passwd(userid, data) path = ENDPOINTS["users"]["password"]["name"] % dict(userid=userid) t.eq(api.response.final_url, "%s%s%s" % (BASE_URL, API_PATH, path)) t.eq(api.response.request.method, ENDPOINTS["users"]["password"]["method"]) t.eq(api.response.status_int, 204) t.eq(req["code"], 204) t.raises(BaruwaAPIError, api.set_user_passwd, userid, data2)
def test_bool_validation(): c = config.Config() t.eq(c.preload_app, False) c.set("preload_app", True) t.eq(c.preload_app, True) c.set("preload_app", "true") t.eq(c.preload_app, True) c.set("preload_app", "false") t.eq(c.preload_app, False) t.raises(ValueError, c.set, "preload_app", "zilch") t.raises(TypeError, c.set, "preload_app", 4)
def test_crypto_auth_reload(): crypto = cfg_crypto(1, "bob: 123\n") signed_pkt = next(pkts('collectd-squares-signed.pkts')) enc_pkt = next(pkts('collectd-squares-encrypted.pkts')) t.raises(ProtocolError, crypto.parse, signed_pkt) t.raises(ProtocolError, crypto.parse, enc_pkt) with open(crypto.auth_file, "a") as f: f.write("alice: 12345678\n") time.sleep(1) t.eq(bool(crypto.parse(signed_pkt)), True) t.eq(bool(crypto.parse(enc_pkt)), True)
def test_bad_span_indexes(): locs = [ {"type": "span", "from": 10, "to": 1}, {"type": "span", "from": 10, "to": 20}, {"type": "span", "from": -1, "to": 10}, {"type": "span", "from": 1, "to": 10}, {"type": "index", "position": -1}, {"type": "index", "position": 10} ] for l in locs: t.raises(IndexError, t.extract, "ACG", l)
def test_get_relay(api): relayid = 1 req = api.get_relay(relayid) path = ENDPOINTS['relays']['get']['name'] % dict(relayid=relayid) t.eq( api.response.final_url, '%s%s%s' % (BASE_URL, API_PATH, path)) t.eq(api.response.request.method, ENDPOINTS['relays']['get']['method']) t.eq(api.response.status_int, 200) t.eq(req['address'], '192.168.1.20') t.raises(BaruwaAPIError, api.get_relay, 7)
def test_get_domain(api): domainid = 1 req = api.get_domain(domainid) path = ENDPOINTS['domains']['get']['name'] % dict(domainid=domainid) t.eq( api.response.final_url, '%s%s%s' % (BASE_URL, API_PATH, path)) t.eq(api.response.request.method, ENDPOINTS['domains']['get']['method']) t.eq(api.response.status_int, 200) t.eq(req['id'], 1) t.eq(req['name'], 'example.com') t.raises(BaruwaAPIError, api.get_domain, 7)
def test_dissalow_call(cx): class PepsiCan(object): def __init__(self): self.caffeine = "zaney!" def __call__(self, arg): return arg * 2 def check(obj, name): return name != "__call__" cx.add_global("PepsiCan", PepsiCan) cx.set_access(check) t.eq(cx.execute("var c = new PepsiCan(); c.caffeine;"), "zaney!") t.raises(t.JSError, cx.execute, "c();")
def test_get_user(api): userid = 5 req = api.get_user(userid) path = ENDPOINTS["users"]["get"]["name"] % dict(userid=userid) t.eq(api.response.final_url, "%s%s%s" % (BASE_URL, API_PATH, path)) t.eq(api.response.request.method, ENDPOINTS["users"]["get"]["method"]) t.eq(api.response.status_int, 200) t.isin("username", req) t.isin("email", req) t.eq(req["username"], "rowdyrough") t.eq(req["email"], "*****@*****.**") t.raises(BaruwaAPIError, api.get_user, 7)
def test_ring_cycle(): t.task("foo")(lambda: 2) t.task("bar")(lambda: "hi") t.task("frog")(lambda: "bird") t.task("foo", ["frog"]) t.task("bar", ["foo"]) t.task("frog", ["bar"]) for task in ["foo", "bar", "frog"]: t.app.clear() t.raises(t.DependencyCycleError, t.app.run, None, [task]) t.eq(t.app._dbg, [])
def test_pos_int_validation(): c = config.Config() t.eq(c.workers, 1) c.set("workers", 4) t.eq(c.workers, 4) c.set("workers", "5") t.eq(c.workers, 5) c.set("workers", "0xFF") t.eq(c.workers, 255) c.set("workers", True) t.eq(c.workers, 1) # Yes. That's right... t.raises(ValueError, c.set, "workers", -21) t.raises(TypeError, c.set, "workers", c)
def assert_crypto(state, testfile, sec_level, auth_file): crypto = cfg_crypto(sec_level, auth_file) i = 0 if state: for data in pkts(testfile): data = crypto.parse(data) t.eq(bool(data), True) i += 1 else: for data in pkts(testfile): t.raises(ProtocolError, crypto.parse, data) i += 1 t.eq(i, 2)
def test_get_organization(api): orgid = 1 req = api.get_organization(orgid) path = ENDPOINTS['organizations']['get']['name'] % dict(orgid=orgid) t.eq( api.response.final_url, '%s%s%s' % (BASE_URL, API_PATH, path)) t.eq( api.response.request.method, ENDPOINTS['organizations']['get']['method']) t.eq(api.response.status_int, 200) t.eq(req['name'], 'My Org') t.raises(BaruwaAPIError, api.get_organization, 7)
def test_obj_method(cx): class Checker(object): def __init__(self): self.names = [] def check(self, obj, name): self.names.append(name) return name != "kablooie" c = Checker() cx.set_access(c.check) cx.add_global("bing", {"kablooie": "bar", "bing": 3}) t.eq(cx.execute('bing["bing"]'), 3) t.raises(t.JSError, cx.execute, 'bing["kablooie"]') t.eq(c.names, ["bing", "kablooie"])
def test_add_arrays(): t.eq(t.FileList("a.c", "b.c") + ["foo.py"], ["a.c", "b.c", "foo.py"]) t.eq(["foo.py"] + t.FileList("a.c", "b.c"), ["foo.py", "a.c", "b.c"]) t.raises(TypeError, lambda: t.FileList("a.c", "b.c") + 1) t.raises(TypeError, lambda: t.FileList("a.c", "b.c") + [1]) t.raises(TypeError, lambda: 1 + t.FileList("a.c", "b.c")) t.raises(TypeError, lambda: [1] + t.FileList("a.c", "b.c"))
def test_on_wrapped_obj(cx): class ShamWow(object): def __init__(self): self.bar = 2 self._bing = 3 def func(): return ShamWow() cx.add_global("whee", func) def check(obj, name): return name in ["__call__", "__init__"] or not name.startswith("_") cx.set_access(check); t.eq(cx.execute("var f = whee(); f.bar;"), 2) t.raises(t.JSError, cx.execute, "f._bing")
def test_callable_validation_for_string(): from os.path import isdir as testfunc t.eq(config.validate_callable(-1)("os.path.isdir"), testfunc) # invalid values tests t.raises(TypeError, config.validate_callable(-1), "") t.raises(TypeError, config.validate_callable(-1), "os.path.not_found_func") t.raises(TypeError, config.validate_callable(-1), "notfoundmodule.func")