refactor: rename drop functions for clarity and update tests

src/plugins/rule34/api.ts

@@ -69,18 +69,18 @@ for (const k of baseResponse) {
     hyperlinkarray.push(k.file_url);
 }
 
-export async function drop() {
+export async function dropRule() {
     if (hyperlinkarray.length === 0) {
         await refresh();
-        return await drop();
+        return await dropRule();
     }
     return hyperlinkarray.pop()!;
 }
 
-export async function drop5() {
+export async function dropRule5() {
     let tmp = "";
     for (let i = 0; i < 5; i++) {
-        tmp += await drop() + "\n";
+        tmp += await dropRule() + "\n";
     }
     return tmp;
 }

src/plugins/rule34/messages.ts

@@ -1,5 +1,5 @@
 import { Bot, Message } from "npm:discordeno@18.0.1";
-import { drop5, drop, refresh } from "./api.ts";
+import { dropRule5, dropRule, refresh } from "./api.ts";
 import { logMessage } from "@root/logging.ts";
 import { defaultString } from "@root/defaultString.ts";
 
@@ -13,7 +13,7 @@ export async function rule34MessageHandler(bot: Bot, message: Message) {
         message.guildId === undefined
       ) {
         bot.helpers.sendMessage(message.channelId, {
-          content: defaultString(await drop()),
+          content: defaultString(await dropRule()),
         });
       }
       break;
@@ -24,7 +24,7 @@ export async function rule34MessageHandler(bot: Bot, message: Message) {
         message.guildId === undefined
       ) {
         bot.helpers.sendMessage(message.channelId, {
-          content: defaultString(await drop5()),
+          content: defaultString(await dropRule5()),
         });
       }
       break;

src/plugins/rule34/test.ts

@@ -1,8 +1,8 @@
-import { assert } from "jsr:@std/assert"
+import { assert } from "jsr:@std/assert";
-import {refresh, drop} from "@root/plugins/rule34/api.ts"
+import { dropRule, refresh } from "@root/plugins/rule34/api.ts";
 
-Deno.test("Test Drop", async() => {
+Deno.test("Test Drop", async () => {
-    await refresh()
+  await refresh();
-    const link = await drop()
+  const link = await dropRule();
-    assert(link !== "", "Empty String was dropped!")
+  assert(link !== "", "Empty String was dropped!");
-})
+});

src/plugins/yandere/api.ts

@@ -1,112 +1,128 @@
-const apiUrl ="https://yande.re/post.json?api_version=2";
+import { assert } from "@std/assert/assert";
+
+const apiUrl = "https://yande.re/post.json?api_version=2";
 
 type APIResponse = {
-    posts: {
+  posts: {
-        id: number;
+    id: number;
-        tags: string;
+    tags: string;
-        created_at: string;
+    created_at: string;
-        creator_id: number;
+    creator_id: number;
-        approver_id: number;
+    approver_id: number;
-        author: string;
+    author: string;
-        change: number;
+    change: number;
-        source: string;
+    source: string;
-        score: number;
+    score: number;
-        md5: string;
+    md5: string;
-        file_size: number;
+    file_size: number;
-        file_ext: string;
+    file_ext: string;
-        file_url: string;
+    file_url: string;
-        is_shown_in_index: boolean;
+    is_shown_in_index: boolean;
-        preview_url: string;
+    preview_url: string;
-        preview_width: number;
+    preview_width: number;
-        preview_height: number;
+    preview_height: number;
-        actual_preview_width: number;
+    actual_preview_width: number;
-        actual_preview_height: number;
+    actual_preview_height: number;
-        sample_url: string;
+    sample_url: string;
-        sample_width: number;
+    sample_width: number;
-        sample_height: number;
+    sample_height: number;
-        sample_file_size: number;
+    sample_file_size: number;
-        jpeg_url: string;
+    jpeg_url: string;
-        jpeg_width: number;
+    jpeg_width: number;
-        jpeg_height: number;
+    jpeg_height: number;
-        rating: string;
+    rating: string;
-        is_rating_locked: boolean;
+    is_rating_locked: boolean;
-        has_children: boolean;
+    has_children: boolean;
-        parent_id: number;
+    parent_id: number;
-        status: string;
+    status: string;
-        is_pending: boolean;
+    is_pending: boolean;
-        width: number;
+    width: number;
-        height: number;
+    height: number;
-        is_held: boolean;
+    is_held: boolean;
-        frames_pending_string: string;
+    frames_pending_string: string;
-        frames_pending: [];
+    frames_pending: [];
-        frames_string: string;
+    frames_string: string;
-        frames: [];
+    frames: [];
-        is_note_locked: boolean;
+    is_note_locked: boolean;
-        last_noted_at: string;
+    last_noted_at: string;
-        last_commented_at: string;
+    last_commented_at: string;
-    }[];
+  }[];
 };
 
 let page = 1;
 
-let baseRequest = await fetch(apiUrl, { headers: { "Accept": "application/json" } })
+let baseRequest = await fetch(apiUrl, {
-    .then(async (response) => {
+  headers: { "Accept": "application/json" },
-        if (!response.ok) {
+})
-            throw new Error("Network response was not ok");
+  .then(async (response) => {
-        }
+    if (!response.ok) {
-        return <APIResponse> await response.json();
+      throw new Error("Network response was not ok");
-    });
+    }
-
+    return <APIResponse> await response.json();
+  });
 
 const hyperlinkarray: string[] = [];
 for (const k of baseRequest.posts) {
-    hyperlinkarray.push(k.file_url);
+  hyperlinkarray.push(k.file_url);
 }
 
-export function setPage(newpage: number) {
+export async function setPage(newpage: number) {
-    page = newpage;
+  page = newpage;
-    hyperlinkarray.length = 0;
+  hyperlinkarray.length = 0;
-    refresh();
+  await refresh();
 }
 
 export function getPage() {
-    return page;
+  return page;
 }
 
-
+//duplicate code, also found in rule34/api.ts
 export async function refresh() {
-    await fetch(`${apiUrl}&page=${page}`, { headers: { "Accept": "application/json" } })
+  await fetch(`${apiUrl}&page=${page}`, {
-        .then(async (response) => {
+    headers: { "Accept": "application/json" },
-            if (!response.ok) {
+  })
-                throw new Error("Network response was not ok");
+    .then(async (response) => {
-            }
+      if (!response.ok) {
-            baseRequest = <APIResponse> await response.json();
+        throw new Error("Network response was not ok");
-            for (const k of baseRequest.posts) {
+      }
-                if (!hyperlinkarray.includes(k.file_url)) {
+      baseRequest = <APIResponse> await response.json();
-                    hyperlinkarray.push(k.file_url);
+      for (const k of baseRequest.posts) {
-                }
+        if (!hyperlinkarray.includes(k.file_url)) {
-            }
+          hyperlinkarray.push(k.file_url);
-        });
+        }
+      }
+    });
 }
 
 export async function fetchNextPage() {
-    page += 1;
+  page += 1;
-    await refresh();
+  await refresh();
 }
 
 export async function dropYandere() {
-    if (hyperlinkarray.length === 0) {
+  if (hyperlinkarray.length === 0) {
-        await fetchNextPage();
+    await fetchNextPage();
-        return await dropYandere();
+    return await dropYandere();
-    }
+  }
-    return hyperlinkarray.pop()!;
+  return hyperlinkarray.pop()!;
 }
 
 export async function dropYandere5() {
-    let tmp = "";
+  let tmp = "";
-    for (let i = 0; i < 5; i++) {
+  for (let i = 0; i < 5; i++) {
-        tmp += await dropYandere() + "\n";
+    tmp += await dropYandere() + "\n";
-    }
+  }
-    return tmp;
+  return tmp;
 }
 
+//Test Stack resize when fetching new data
+Deno.test("Refresh Stack", async () => {
+  await refresh();
+  const previousStack = [...hyperlinkarray];
+  await new Promise((r) => setTimeout(r, 10000));
+  await refresh();
+  assert(
+    previousStack.length <= hyperlinkarray.length,
+    "Stack-size did not increase as expected!",
+  );
+});

src/plugins/yandere/test.ts

@@ -0,0 +1,32 @@
+import { assert } from "@std/assert/assert";
+import {
+  dropYandere,
+  getPage,
+  refresh,
+  setPage,
+} from "@root/plugins/yandere/api.ts";
+import { assertEquals } from "@std/assert/equals";
+//tests
+/*
+get page,
+switch page,
+drop,
+ */
+
+Deno.test("Get default Page", async () => {
+  assertEquals(getPage(), 1);
+});
+
+Deno.test("Switching page", async () => {
+  assertEquals(getPage(), 1);
+  await setPage(2);
+  assertEquals(getPage(), 2);
+  await setPage(100);
+  assertEquals(getPage(), 100);
+});
+
+Deno.test("Test Drop", async () => {
+  await refresh();
+  const link = await dropYandere();
+  assert(link !== "", "Empty String was dropped!");
+});