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_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_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_not_synthed():
    @t.synth()
    def synth(task):
        task.synth(t.tmpfname())
    
    t.raises(t.FileSynthError, t.app.run, None, ["synth"])
    

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_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_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://test:[email protected]%s:%s/auth" % (HOST, PORT)
    res = Resource(u)
    r = res.get()
    t.eq(r.status_int, 200)
    u = "http://test:[email protected]%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_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_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_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_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"], "[email protected]")
    t.raises(BaruwaAPIError, api.get_aliases, 7)

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)