From 9503419b0e1d102e732ebfdcd2fb65975e3e8840 Mon Sep 17 00:00:00 2001
From: Sebastian Gerske <sebastian.gerske@gmail.com>
Date: Fri, 23 Nov 2018 12:40:49 +0100
Subject: [PATCH] added more functionality to event listener

---
 src/keeper/Event.ts               | 13 +++++-
 src/keeper/EventListener.ts       | 14 +++---
 test/keeper/Event.test.ts         | 75 +++++++++++++++++++++++++++++++
 test/keeper/EventListener.test.ts | 48 ++++++++++----------
 4 files changed, 120 insertions(+), 30 deletions(-)
 create mode 100644 test/keeper/Event.test.ts

diff --git a/src/keeper/Event.ts b/src/keeper/Event.ts
index e1d8b97..8bb5b8f 100644
--- a/src/keeper/Event.ts
+++ b/src/keeper/Event.ts
@@ -1,9 +1,11 @@
 import GenericContract from "./contracts/GenericContract"
+import EventListener from "./EventListener"
 
 export default class Event {
 
     private poller
     private lastBlock: number = 0
+    private interval: number = 200
 
     constructor(private contractName: string,
                 private eventName: string,
@@ -16,7 +18,16 @@ export default class Event {
     }
 
     public listen(callback: any) {
-        this.poller = setTimeout(() => this.handler(callback), 200)
+        this.poller = setTimeout(
+            () => this.handler(callback),
+            this.interval)
+    }
+
+    public async listenOnce() {
+        this.listen((events: any[]) => {
+            EventListener.unsubscribe(this)
+            return events
+        })
     }
 
     private async handler(callback: any) {
diff --git a/src/keeper/EventListener.ts b/src/keeper/EventListener.ts
index 00fe7c2..d150c58 100644
--- a/src/keeper/EventListener.ts
+++ b/src/keeper/EventListener.ts
@@ -13,13 +13,17 @@ export default class EventListener {
     }
 
     public static unsubscribe(event): boolean {
-
-        EventListener.events = EventListener.events.splice(
-            EventListener.events.findIndex((e) => e === event),
-            1)
-
+        event.stopListen()
+        const i = EventListener.events.indexOf(event)
+        if (i > -1) {
+            EventListener.events.splice(i, 1)
+        }
         return true
     }
 
+    public static count() {
+        return EventListener.events.length
+    }
+
     private static events: Event[] = []
 }
diff --git a/test/keeper/Event.test.ts b/test/keeper/Event.test.ts
new file mode 100644
index 0000000..4dc51a5
--- /dev/null
+++ b/test/keeper/Event.test.ts
@@ -0,0 +1,75 @@
+import {assert} from "chai"
+import ConfigProvider from "../../src/ConfigProvider"
+import EventListener from "../../src/keeper/EventListener"
+import Keeper from "../../src/keeper/Keeper"
+import Account from "../../src/ocean/Account"
+import Ocean from "../../src/ocean/Ocean"
+import config from "../config"
+import TestContractHandler from "./TestContractHandler"
+
+let keeper: Keeper
+let ocean: Ocean
+let accounts: Account[]
+
+describe("EventListener", () => {
+
+    before(async () => {
+        ConfigProvider.setConfig(config)
+        await TestContractHandler.prepareContracts()
+        keeper = await Keeper.getInstance()
+        assert(keeper)
+        ocean = await Ocean.getInstance(config)
+        assert(ocean)
+        accounts = await ocean.getAccounts()
+        assert(accounts)
+    })
+
+    describe("#listen()", () => {
+
+        it("should listen to an event", (done) => {
+
+            const acc = accounts[1]
+
+            const event = EventListener.subscribe("OceanToken",
+                "Transfer",
+                {
+                    to: acc.getId(),
+                })
+
+            event.listen((events) => {
+
+                assert(events)
+                assert(events.length === 2)
+                done()
+            })
+
+            const {market} = keeper
+
+            market.requestTokens(400, acc.getId())
+            market.requestTokens(400, acc.getId())
+        })
+    })
+
+    describe("#listenOnce()", () => {
+
+        xit("should listen once", async () => {
+
+            const acc = accounts[1]
+
+            const event = EventListener.subscribe("OceanToken",
+                "Transfer",
+                {
+                    to: acc.getId(),
+                })
+
+            const events = await event.listenOnce()
+
+            assert(events, "no events")
+
+            const {market} = keeper
+
+            market.requestTokens(400, acc.getId())
+        })
+    })
+
+})
diff --git a/test/keeper/EventListener.test.ts b/test/keeper/EventListener.test.ts
index 9b40c35..3634595 100644
--- a/test/keeper/EventListener.test.ts
+++ b/test/keeper/EventListener.test.ts
@@ -29,40 +29,40 @@ describe("EventListener", () => {
         it("should subscribe to an event", (done) => {
 
             const acc = accounts[1]
+            const countBefore = EventListener.count()
 
             const event = EventListener.subscribe("OceanToken",
                 "Transfer",
                 {
                     to: acc.getId(),
                 })
+            assert(event)
 
-            event.listen((events) => {
-
-                assert(events)
-                assert(events.length === 2)
-                done()
-            })
-
-            const {market} = keeper
-
-            market.requestTokens(400, acc.getId())
-            market.requestTokens(400, acc.getId())
-        })
-    })
-
-    describe("#unsubscribe()", () => {
-
-        it("should subscribe to an event", (done) => {
-
-            const event = EventListener.subscribe("OceanToken",
-                "Transfer",
-                {})
-
-            const unsubscribed = EventListener.unsubscribe(event)
-            assert(unsubscribed)
+            const countAfter = EventListener.count()
+            assert(countBefore + 1 === countAfter, `${countBefore}${countAfter}`)
 
             done()
         })
     })
 
+    describe("#unsubscribe()", () => {
+
+        it("should unsubscribe from an event", (done) => {
+
+            const countBefore = EventListener.count()
+            const event = EventListener.subscribe("OceanToken",
+                "Transfer",
+                {})
+            const count = EventListener.count()
+
+            const unsubscribed = EventListener.unsubscribe(event)
+            assert(unsubscribed)
+
+            const countAfter = EventListener.count()
+            assert(count > countBefore, `${count}${countAfter}`)
+            assert(countBefore === countAfter, `${countBefore}${countAfter}`)
+            done()
+        })
+    })
+
 })