def test_event_appendBulk():

    e = Event(bulk=True)
    ee = Event({"one": 1})

    e.appendBulk(ee)
    assert e.dump()["data"][0]["uuid"] == ee.data["uuid"]

def test_module_unpack():

    actor_config = ActorConfig('unpack', 100, 1, {}, "")
    unpack = Unpack(actor_config)

    unpack.pool.queue.inbox.disableFallThrough()
    unpack.pool.queue.outbox.disableFallThrough()
    unpack.start()

    bulk = Event(bulk=True)

    for _ in range(0, 10):
        bulk.appendBulk(Event())

    unpack.pool.queue.inbox.put(bulk)

    for _ in range(0, 10):
        assert getter(unpack.pool.queue.outbox)

    try:
        getter(unpack.pool.queue.outbox)
    except Exception:
        assert True
    else:
        assert False

def test_module_fanout():

    actor_config = ActorConfig('fanout', 100, 1, {})
    fanout = Fanout(actor_config, deep_copy=True)
    fanout.pool.queue.inbox.disableFallThrough()

    fanout.pool.createQueue("one")
    fanout.pool.queue.one.disableFallThrough()

    fanout.pool.createQueue("two")
    fanout.pool.queue.two.disableFallThrough()

    fanout.start()

    e = Event('test')
    e.setData("hello")

    fanout.pool.queue.inbox.put(e)
    one = getter(fanout.pool.queue.one)
    two = getter(fanout.pool.queue.two)

    fanout.stop()

    assert one.raw()["test"]["data"] == "hello"
    assert two.raw()["test"]["data"] == "hello"
    assert id(one) != id(two)

def test_event_clone():

    a = Event({"one": 1, "two": 2})
    b = a.clone()

    assert id(a.data) != id(b.data)
    assert not a.data["cloned"]
    assert b.data["cloned"]
    assert b.data["uuid_previous"][0] == a.data["uuid"]

def test_event_get_error():

    e = Event({"one": 1, "two": {"three": 3}})
    try:
        e.get("data.blah")
    except KeyError:
        assert True
    else:
        assert False

def test_event_render_error():

    e = Event({"one": 1, "two": 2})

    try:
        e.render("{{data.one} is a number and so is {{data.two}}")
    except InvalidData:
        assert True
    else:
        assert False

def test_merge_fail():

    e = Event("hi")

    try:
        e.merge(["two"])
    except InvalidData:
        assert True
    else:
        assert False

def test_extractBulkItems():

    from wishbone.event import extractBulkItems

    e = Event(bulk=True)
    e.appendBulk(Event({"one": 1}))
    e.appendBulk(Event({"two": 2}))
    e.appendBulk(Event({"three": 3}))

    for item in extractBulkItems(e):
        assert isinstance(item, Event)

def test_event_delete():

    a = Event({"one": 1, "two": 2})
    a.delete("data.two")

    try:
        a.get("data.two")
    except KeyError:
        assert True
    else:
        assert False

def test_extractBulkItemValues():

    from wishbone.event import extractBulkItemValues

    e = Event(bulk=True)
    e.appendBulk(Event({"one": 1}))
    e.appendBulk(Event({"two": 2}))
    e.appendBulk(Event({"three": 3}))

    for item in extractBulkItemValues(e, "data"):
        assert item in [{"one": 1}, {"two": 2}, {"three": 3}]

    def __log(self, level, message):

        event = Event(self.name)
        event.data = Log(time(), level, getpid(), self.name, message)

        while True:
            try:
                self.logs.put(event)
                break
            except QueueFull:
                sleep(0.1)

    def metricProducer(self):
        '''A greenthread which collects the queue metrics at the defined interval.'''

        self.__run.wait()
        hostname = socket.gethostname()
        while self.loop():
            for queue in self.pool.listQueues(names=True):
                for metric, value in self.pool.getQueue(queue).stats().iteritems():
                    event = Wishbone_Event(self.name)
                    event.data = Metric(time=time(), type="wishbone", source=hostname, name="module.%s.queue.%s.%s" % (self.name, queue, metric), value=value, unit="", tags=())
                    self.submit(event, self.pool.queue.metrics)
            sleep(self.frequency)

def test_event_slurp_bad():

    a = Event()
    del(a.data["uuid"])
    b = Event()

    try:
        b.slurp(a.dump())
    except InvalidData:
        assert True
    else:
        assert False

def test_event_appendBulkFull():

    e = Event(bulk=True, bulk_size=1)
    ee = Event({"one": 1})

    e.appendBulk(ee)
    try:
        e.appendBulk(ee)
    except BulkFull:
        assert True
    else:
        assert False

    def processEvent(self, data, meta, queue):
        '''
        The callback executed for each Wishbone event to be created out of a
        single http request.
        '''

        e = Event(data)
        e.set(meta, 'tmp.%s' % (self.name))
        e.renderKwargs(self.kwargs_template)
        self.submit(e, queue)

        return self.getResponse(e, queue)

def test_event_dump():

    from wishbone.event import EVENT_RESERVED

    data = {"one": 1, "two": 2}
    a = Event(data)
    result = a.dump()

    for key in EVENT_RESERVED:
        assert key in result

    assert result["data"] == data
    assert isinstance(result["timestamp"], float)

    def generateEvent(self, data={}, destination=None):
        '''
        Generates a new event.

        This function can get overridden by
        ``wishbone.module.InputModule._generateNativeEvent``.

        The provided ``data`` will be traversed in search of valid templates
        which then will be rendered.

        Args:
            data (``data``): The payload to add to the event.
            destination (None): The destination key to write the data to

        Returns:
            wishbone.event.Event: An event containing ``data`` as a payload.

        '''
        if destination in [None, "data"]:
            event = Wishbone_Event(data)
            event.renderField(destination, self.env_template)
        else:
            event = Wishbone_Event()
            event.set(data, destination)
            event.renderField(destination, self.env_template)
        return event

def test_module_msgpackdecode():

    actor_config = ActorConfig('msgpackdecode', 100, 1, {})
    msgpackdecode = MSGPackDecode(actor_config)

    msgpackdecode.pool.queue.inbox.disableFallThrough()
    msgpackdecode.pool.queue.outbox.disableFallThrough()
    msgpackdecode.start()

    e = Event('test')
    e.setData('\x93\x01\x02\x03')

    msgpackdecode.pool.queue.inbox.put(e)
    one = getter(msgpackdecode.pool.queue.outbox)
    assert one.data == [1, 2, 3]

def test_module_jsonencode():

    actor_config = ActorConfig('jsonencode', 100, 1, {})
    jsonencode = JSONEncode(actor_config)

    jsonencode.pool.queue.inbox.disableFallThrough()
    jsonencode.pool.queue.outbox.disableFallThrough()
    jsonencode.start()

    e = Event('test')
    e.setData(["one", "two", "three"])

    jsonencode.pool.queue.inbox.put(e)
    one = getter(jsonencode.pool.queue.outbox)
    assert one.data == '["one", "two", "three"]'

def test_module_msgpackencode():

    actor_config = ActorConfig("msgpackencode", 100, 1, {})
    msgpackencode = MSGPackEncode(actor_config)

    msgpackencode.pool.queue.inbox.disableFallThrough()
    msgpackencode.pool.queue.outbox.disableFallThrough()
    msgpackencode.start()

    e = Event("test")
    e.setData([1, 2, 3])

    msgpackencode.pool.queue.inbox.put(e)
    one = getter(msgpackencode.pool.queue.outbox)
    assert one.data == "\x93\x01\x02\x03"