Added configurable cache-entry expiration.

Author: chrisdenman

README.md

@@ -1,4 +1,4 @@
-# [ID Bot](https://github.com/chrisdenman/id-bot) 0.0.2
+# [ID Bot](https://github.com/chrisdenman/id-bot) 0.0.3
                                                                 
 ![An stylised image of the project's logo formed of a lower-case i cursively joining a capitalised D](res/img/id-gum-logo.png)
 
@@ -27,10 +27,18 @@ A working version of node is required (Tested on `v21.6.2`).
 - Test reports are located [here](build/tests/html/vitest.html).
 - Coverage reports are located [here](build/tests/coverage/index.html).
 
+`npm run check`
+- Runs: linting, auditing, testing. 
+
 ### Linting
 
 `npm run lint`
 
+### Package Auditing
+
+`npm run audit`
+
+
 ## Production Plugins
 
 - `discord.js`

VERSIONS.md

@@ -3,3 +3,5 @@
 0.0.1 - `First working private version that supports attached images.`
 
 0.0.2 - `Functionality added to require the identification of emoji and custom (Discord) emoji.`
+
+0.0.3 - `Cache expiration management.`

package-lock.json

@@ -1,14 +1,16 @@
 {
   "name": "@ceilingcat/id-bot",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A discord bot to remind users to tag uploaded images with identifiers.",
   "scripts": {
+    "lint": "eslint \"src/*/*.js\"",
+    "audit": "npm audit --registry=https://registry.npmjs.org",
+    "test": "vitest --coverage --config ./vitest.config.ts",
+    "check": "run-s lint audit test",
     "start": "run-s execute",
     "execute": "run-p auth-server id-bot",
-    "test": "vitest --coverage --config ./vitest.config.ts",
     "id-bot": "node src/js/node-starter.js",
-    "auth-server": "node src/js/auth-server.js",
-    "lint": "eslint \"src/*/*.js\""
+    "auth-server": "node src/js/auth-server.js"
   },
   "main": "build/src/js/id-bot.js",
   "type": "module",

package.json

@@ -69,7 +69,20 @@ const createIdBotReply = function (userMessage, replyContent) {
 };
 
 describe("Application startup and shutdown", () => {
-    let factory, process, client, discordInterfaceHarness, idBot, application;
+    let factory, process, client, discordInterfaceHarness, cache, unboundCacheExpirator, idBot, application;
+
+    const withExpirator = (altCacheExpiratorProvider = undefined) => {
+        cache = factory.createCache();
+        unboundCacheExpirator = (altCacheExpiratorProvider && altCacheExpiratorProvider(cache)) ||
+            factory.createCacheExpirator(cache);
+        idBot = new IdBot(
+            cache,
+            unboundCacheExpirator,
+            discordInterfaceHarness,
+            new Logger(console, `IdBot(${CLIENT_ID})`)
+        );
+        application = new Application(process, idBot);
+    };
 
     beforeEach(() => {
         factory = new Factory();
@@ -88,32 +101,18 @@ describe("Application startup and shutdown", () => {
             factory,
             factory.createLogger(`DiscordInterface(${CLIENT_ID})`),
             CLIENT_ID);
-        idBot = new IdBot(factory.createCache(), discordInterfaceHarness, new Logger(console, `IdBot(${CLIENT_ID})`));
-        application = new Application(process, idBot);
+
+        withExpirator();
     });
 
-    // it("That  failures to login are resolved by logging them and rethrowing.", () => {
-    //     factory = new Factory();
-    //     process = {on: vi.fn(), exit: vi.fn()};
-    //     client = {once: vi.fn(), on: vi.fn(), login: vi.fn().mockImplementationOnce(REJECTS_TO)};
-    //     discordInterfaceHarness = new DiscordInterfaceHarness(
-    //         client,
-    //         factory,
-    //         factory.createLogger(`DiscordInterface for ${CLIENT_ID}`),
-    //         CLIENT_ID);
-    //     idBot = new IdBot(factory.createCache(), discordInterfaceHarness, new Logger(console, "IdBot"));
-    //     let unhandledErrorCaught = false;
-    //     try {
-    //         new Application(process, idBot).start("");
-    //     } catch(e) {
-    //         unhandledErrorCaught = true;
-    //     }
-    //     expect(unhandledErrorCaught).toBe(true);
-    // });
+    afterEach(() => {
+        application.stop();
+        vi.restoreAllMocks();
+    });
 
     it("That messages authored by other bots are ignored even if they contain attachments that could be prompted in respect of.", () => {
         application.start(TOKEN);
-        discordInterfaceHarness.onClientReady();        
+        discordInterfaceHarness.onClientReady();
 
         const discordJsMessage = createDiscordJsMessage(CONTENT_EMPTY, ["image/png"], AUTHOR_ID__NOT_US, MessageType.Default, undefined, true);
         discordInterfaceHarness.onMessageCreate(discordJsMessage);
@@ -208,6 +207,43 @@ describe("Application startup and shutdown", () => {
         )
     );
 
+    describe(
+        "That quickly culling cache entries means ",
+        () => {
+            it(
+                `Something`,
+                async () => {
+                    vi.useRealTimers();
+
+                    withExpirator(c => factory.createCacheExpirator(c, 10, 1));
+
+                    application.start(TOKEN);
+                    discordInterfaceHarness.onClientReady();
+
+                    const userMessage = createDiscordJsMessage("ID: Something", []);
+                    discordInterfaceHarness.onMessageCreate(userMessage);
+
+                    // Discord.js creation event for our previous reply, idBot caches referenced message to idBot reply if the message is not correctly identified
+                    discordInterfaceHarness.onMessageCreate(createIdBotReply(userMessage, OVER_DESCRIBED_REMINDER_MESSAGE));
+                    const updatedUserMessage = createDiscordJsMessage(
+                        "Blah blah blah.",
+                        [],
+                        AUTHOR_ID__NOT_US,
+                        MessageType.Default,
+                        undefined,
+                        false,
+                        userMessage.id
+                    );
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    discordInterfaceHarness.onMessageUpdate(userMessage, updatedUserMessage);
+                    expect(updatedUserMessage.channel.messages.delete).not.toHaveBeenCalled();
+                    
+                    application.stop();
+                }
+            );
+        }
+    );
+
     it("That normal shutdown closes the IdBot instance and returns the correct process exit code", () => {
         application.start(TOKEN);
         application.stop();

src/__tests__/application.spec.js

@@ -1,4 +1,4 @@
-import {beforeEach, describe, expect, it} from "vitest";
+import {beforeEach, describe, expect, it, vi} from "vitest";
 import {Factory} from "../js/factory.js";
 import {createUuid} from "./uuid.js";
 
@@ -17,83 +17,122 @@ describe("Tests for our Cache", () => {
     /**
      * @type *
      */
-    let key, value;
+    let k0, v0, k1, v1;
+
+    const setK0V0 = () => {
+        cache.set(k0, v0);
+
+        return cache;
+    };
+
+    const setK1V1 = () => {
+        cache.set(k1, v1);
+
+        return cache;
+    };
 
     beforeEach(() => {
         factory = new Factory();
         cache = factory.createCache();
-        key = createUuid();
-        value = createUuid();
+        [k0, v0, k1, v1] = [createUuid(), createUuid(), createUuid(), createUuid()];
     });
 
     it("We can store and retrieve things from the cache", () => {
-        cache.set(key, value);
-
-        expect(cache.get(key)).toBe(value);
+        expect(setK0V0().get(k0)).toBe(v0);
     });
 
     it("Newly added cache entries have the required properties set", () => {
-        cache.set(key, value);
-        const meta = cache.getMeta(key);
+        setK0V0();
 
-        expect(meta.key).toBe(key);
-        expect(meta.value).toBe(value);
+        const meta = cache.getMeta(k0);
+
+        expect(meta.key).toBe(k0);
         expect(meta.createdAt).toBeDefined();
     });
 
     it("Newly added cache entries have a 'createdAt' value greater or equal than that sampled before population.", () => {
         const then = factory.utcTimeStampNow;
-        cache.set(key, value);
-        const meta = cache.getMeta(key);
+
+        const meta = setK0V0().getMeta(k0);
 
         expect(meta.createdAt).toBeGreaterThanOrEqual(then);
     });
 
     it("Metadata records the last accessed time of an entry correctly.", () => {
-        cache.set(key, value);
-        const metaBefore = cache.getMeta(key);
+        setK0V0();
+        const metaBefore = cache.getMeta(k0);
 
-        expect(metaBefore.lastAccessedAt).toBeUndefined();
+        expect(metaBefore.lastAccessedAt).toEqual(metaBefore.createdAt);
 
         const then = factory.utcTimeStampNow;
-        cache.get(key);
-        const metaAfter = cache.getMeta(key);
+        cache.get(k0);
+        const metaAfter = cache.getMeta(k0);
 
         expect(metaAfter.lastAccessedAt).toBeGreaterThanOrEqual(then);
     });
 
     it("Metadata records the last update time of an entry correctly.", () => {
-        cache.set(key, value);
-        const newValue = createUuid();
-        const metaBefore = cache.getMeta(key);
+        setK0V0();
+        const newValue = v1;
+        const metaBefore = cache.getMeta(k0);
 
-        expect(metaBefore.updatedAt).toBeUndefined();
-        expect(metaBefore.value).toBe(value);
+        expect(metaBefore.lastUpdatedAt).toBeUndefined();
 
         const then = factory.utcTimeStampNow;
-        cache.set(key, newValue);
-        const metaAfter = cache.getMeta(key);
+        cache.set(k0, newValue);
+        const metaAfter = cache.getMeta(k0);
 
-        expect(metaAfter.updatedAt).toBeGreaterThanOrEqual(then);
-        expect(metaAfter.value).toBe(newValue);
+        expect(metaAfter.lastUpdatedAt).toBeGreaterThanOrEqual(then);
     });
 
     it("Retrieving metadata returns undefined if the key is unknown.", () => {
-        expect(cache.getMeta(key)).toBeUndefined();
+        expect(cache.getMeta(k0)).toBeUndefined();
     });
 
     it("Retrieving values returns undefined if the key is unknown.", () => {
-        expect(cache.get(key)).toBeUndefined();
+        expect(cache.get(k0)).toBeUndefined();
     });
 
     it("Requests to remove unknown keys are allowed.", () => {
-        expect(cache.remove(key)).toEqual(false);
+        expect(cache.remove(k0)).toEqual(false);
     });
 
     it("The removal by key works.", () => {
-        cache.set(key, value);
-        expect(cache.remove(key)).toBe(true);
-        expect(cache.remove(key)).toBe(false);
+        setK0V0();
+
+        expect(cache.remove(k0)).toBe(true);
+        expect(cache.remove(k0)).toBe(false);
+    });
+
+    it("That metaData returns the metadata elements.", () => {
+        setK0V0();
+        const metas = cache.metaData;
+        /**
+         * @type {CacheMeta}
+         */
+        const firstElement = metas.next().value;
+        expect(cache.get(firstElement.key)).toBe(v0);
+        expect(metas.next().done).toBe(true);
+    });
+
+    it("That metaData returns elements sorted by decreasing lastAccessedAt values.", async () => {
+        vi.useRealTimers();
+
+        setK1V1();
+
+        await new Promise(resolve => setTimeout(resolve, 100));
+        setK0V0();
+        const metas = cache.metaData;
+
+        /**
+         * @type {CacheMeta}
+         */
+        const meta0 = metas.next().value;
+        metas.next();
+
+        expect(metas.next().done).toBe(true);
+
+        expect(cache.get(meta0.key)).toBe(v1);
     });
 
 });

src/__tests__/cache.spec.js

@@ -1,30 +1,17 @@
-import {assert} from "vitest";
 import {DiscordInterface} from "../js/discord-interface";
 
 class DiscordInterfaceHarness extends DiscordInterface {
 
-    /**
-     * @type {String}
-     */
-    #channelId;
-
     /**
      * @type {Map}
      */
     #messageIdToMessage;
 
-    constructor(client, factory, logger, clientId, channelId) {
+    constructor(client, factory, logger, clientId) {
         super(client, factory, logger, clientId);
-        this.#channelId = channelId;
         this.#messageIdToMessage = new Map();
     }
 
-    fetchMessage(channel, messageId, f) {
-        assert(this.#channelId === channel.id);
-        const message = this.#messageIdToMessage.get(messageId);
-        f(this._createIdBotMessage(message));
-    }
-
     onClientReady() {
         super._onClientReady(this._client);
     }