#155 ローディングアニメーションを修正、ユニットテストを追加

Author: ienaga

src/application/content/Builder/service/ContentBuilderService.test.ts

@@ -2,11 +2,16 @@ import { execute } from "./ContentBuilderService";
 import { ShapeContent } from "../../ShapeContent";
 import { loaderInfoMap } from "../../../variable/LoaderInfoMap";
 import { Shape, type LoaderInfo } from "@next2d/display";
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi, beforeEach } from "vitest";
 
 describe("ContentBuilderService Test", () =>
 {
-    it("test case", () =>
+    beforeEach(() =>
+    {
+        loaderInfoMap.clear();
+    });
+
+    it("should sync display object when all data is valid", () =>
     {
         const displayObject = new ShapeContent();
 
@@ -18,9 +23,8 @@ describe("ContentBuilderService Test", () =>
 
         const map: Map<string, number> = new Map();
         map.set(Shape.namespace, 1);
-        loaderInfoMap.clear();
         loaderInfoMap.set(Shape.namespace, {
-            "data": { 
+            "data": {
                 "stage": {
                     "width": 100,
                     "height": 100,
@@ -49,4 +53,72 @@ describe("ContentBuilderService Test", () =>
         expect(state).toBe("sync");
         expect(displayObject.characterId).toBe(1);
     });
+
+    it("should return early when loaderInfo is not found", () =>
+    {
+        const displayObject = new ShapeContent();
+        displayObject.$sync = vi.fn();
+
+        execute(displayObject);
+
+        expect(displayObject.$sync).not.toHaveBeenCalled();
+        expect(displayObject.characterId).toBe(-1);
+    });
+
+    it("should return early when loaderInfo.data is null", () =>
+    {
+        const displayObject = new ShapeContent();
+        displayObject.$sync = vi.fn();
+
+        loaderInfoMap.set(Shape.namespace, {
+            "data": null
+        } as unknown as LoaderInfo);
+
+        execute(displayObject);
+
+        expect(displayObject.$sync).not.toHaveBeenCalled();
+        expect(displayObject.characterId).toBe(-1);
+    });
+
+    it("should return early when characterId is not found in symbols", () =>
+    {
+        const displayObject = new ShapeContent();
+        displayObject.$sync = vi.fn();
+
+        const map: Map<string, number> = new Map();
+        // Do not set the namespace in the map
+        loaderInfoMap.set(Shape.namespace, {
+            "data": {
+                "symbols": map,
+                "characters": []
+            }
+        } as unknown as LoaderInfo);
+
+        execute(displayObject);
+
+        expect(displayObject.$sync).not.toHaveBeenCalled();
+        expect(displayObject.characterId).toBe(-1);
+    });
+
+    it("should return early when character is not found", () =>
+    {
+        const displayObject = new ShapeContent();
+        displayObject.$sync = vi.fn();
+
+        const map: Map<string, number> = new Map();
+        map.set(Shape.namespace, 5); // characterId 5 doesn't exist in characters array
+        loaderInfoMap.set(Shape.namespace, {
+            "data": {
+                "symbols": map,
+                "characters": [
+                    { "extends": Shape.namespace }
+                ]
+            }
+        } as unknown as LoaderInfo);
+
+        execute(displayObject);
+
+        expect(displayObject.$sync).not.toHaveBeenCalled();
+        expect(displayObject.characterId).toBe(-1);
+    });
 });

src/application/service/QueryStringParserService.ts

@@ -18,9 +18,7 @@ export const execute = (name: string = ""): IQueryObject =>
      * 前のシーンのクエリデータを初期化
      * Initialize query data from previous scene
      */
-    if (query.size) {
-        query.clear();
-    }
+    query.clear();
 
     /**
      * QueryStringがあれば分解

src/application/usecase/ApplicationGotoViewUseCase.test.ts

@@ -150,4 +150,95 @@ describe("ApplicationGotoViewUseCase Test", () =>
         expect(response.has("")).toBe(false);
         expect(response.get("valid")).toEqual({ data: "should be set" });
     });
+
+    it("execute test case4: navigation with loading enabled", async () =>
+    {
+        const { execute: queryStringParserService } = await import("../service/QueryStringParserService");
+        const { execute: requestUseCase } = await import("../../infrastructure/usecase/RequestUseCase");
+        const { LoadingService } = await import("../../domain/service/LoadingService");
+        const { ScreenCaptureService } = await import("../../domain/service/ScreenCaptureService");
+
+        $setConfig({
+            platform: "web",
+            spa: false,
+            stage: {
+                width: 800,
+                height: 600,
+                fps: 60
+            },
+            loading: {
+                callback: async () => null
+            }
+        });
+
+        vi.mocked(queryStringParserService).mockReturnValue({
+            name: "home",
+            queryString: ""
+        });
+        vi.mocked(requestUseCase).mockResolvedValue([]);
+
+        await execute(mockApplication, "home");
+
+        expect(ScreenCaptureService.add).toHaveBeenCalled();
+        expect(LoadingService.start).toHaveBeenCalled();
+        expect(LoadingService.end).toHaveBeenCalled();
+        expect(ScreenCaptureService.dispose).toHaveBeenCalled();
+    });
+
+    it("execute test case5: response with callback should execute callback", async () =>
+    {
+        const { execute: queryStringParserService } = await import("../service/QueryStringParserService");
+        const { execute: requestUseCase } = await import("../../infrastructure/usecase/RequestUseCase");
+        const { execute: executeCallbackUseCase } = await import("./ExecuteCallbackUseCase");
+
+        vi.mocked(queryStringParserService).mockReturnValue({
+            name: "page",
+            queryString: ""
+        });
+
+        const mockCallback = vi.fn();
+        const mockResponses = [
+            { name: "data", response: { value: 123 }, callback: mockCallback }
+        ];
+        vi.mocked(requestUseCase).mockResolvedValue(mockResponses);
+
+        await execute(mockApplication, "page");
+
+        expect(executeCallbackUseCase).toHaveBeenCalledWith(mockCallback, { value: 123 });
+    });
+
+    it("execute test case6: gotoView callback should be executed when view is returned", async () =>
+    {
+        const { execute: queryStringParserService } = await import("../service/QueryStringParserService");
+        const { execute: requestUseCase } = await import("../../infrastructure/usecase/RequestUseCase");
+        const { ViewBinderService } = await import("../../domain/service/ViewBinderService");
+        const { execute: executeCallbackUseCase } = await import("./ExecuteCallbackUseCase");
+
+        const mockGotoViewCallback = vi.fn();
+        $setConfig({
+            platform: "web",
+            spa: false,
+            stage: {
+                width: 800,
+                height: 600,
+                fps: 60
+            },
+            gotoView: {
+                callback: mockGotoViewCallback
+            }
+        });
+
+        vi.mocked(queryStringParserService).mockReturnValue({
+            name: "withCallback",
+            queryString: ""
+        });
+        vi.mocked(requestUseCase).mockResolvedValue([]);
+
+        const mockView = { name: "MockView" };
+        vi.mocked(ViewBinderService.bind).mockResolvedValue(mockView as any);
+
+        await execute(mockApplication, "withCallback");
+
+        expect(executeCallbackUseCase).toHaveBeenCalledWith(mockGotoViewCallback, mockView);
+    });
 });

src/application/usecase/ApplicationInitializeUseCase.test.ts

@@ -71,4 +71,43 @@ describe("ApplicationInitializeUseCase", () =>
         execute(app, config, buildPackages);
         expect(state).toBe("");
     });
+
+    it("popstate handler sets popstate flag and triggers gotoView", async () =>
+    {
+        let popstateCallback: (() => Promise<void>) | null = null;
+        window.addEventListener = vi.fn((name, callback) =>
+        {
+            if (name === "popstate") {
+                popstateCallback = callback as () => Promise<void>;
+            }
+        });
+
+        const app = new Application();
+        app.gotoView = vi.fn().mockResolvedValue(undefined);
+
+        const config: IConfig = {
+            "platform": "web",
+            "stage": {
+                "width": 640,
+                "height": 480,
+                "fps": 60
+            },
+            "spa": true
+        };
+
+        const buildPackages: IPackages = [[
+            "view", View
+        ]];
+
+        execute(app, config, buildPackages);
+
+        expect(popstateCallback).not.toBeNull();
+        expect(app.popstate).toBe(false);
+
+        // Trigger the popstate event handler
+        await popstateCallback!();
+
+        expect(app.popstate).toBe(true);
+        expect(app.gotoView).toHaveBeenCalled();
+    });
 });

src/application/variable/Context.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it, vi } from "vitest";
+
+describe("Context variable Test", () =>
+{
+    it("$getContext should throw error when context is not initialized", async () =>
+    {
+        // Reset modules to get a fresh Context module state
+        vi.resetModules();
+        const { $getContext } = await import("./Context");
+
+        expect(() => $getContext()).toThrow("Context is not initialized. Call run() first.");
+    });
+
+    it("$setContext should set the context and $getContext should return it", async () =>
+    {
+        vi.resetModules();
+        const { $getContext, $setContext } = await import("./Context");
+        const { Context } = await import("../Context");
+        const { MovieClip } = await import("@next2d/display");
+
+        const root = new MovieClip();
+        const context = new Context(root);
+
+        $setContext(context);
+        const result = $getContext();
+
+        expect(result).toBe(context);
+        expect(result.root).toBe(root);
+    });
+
+    it("$getContext should return the same context that was set", async () =>
+    {
+        vi.resetModules();
+        const { $getContext, $setContext } = await import("./Context");
+        const { Context } = await import("../Context");
+        const { MovieClip } = await import("@next2d/display");
+
+        const root1 = new MovieClip();
+        const context1 = new Context(root1);
+        $setContext(context1);
+        expect($getContext()).toBe(context1);
+
+        const root2 = new MovieClip();
+        const context2 = new Context(root2);
+        $setContext(context2);
+        expect($getContext()).toBe(context2);
+    });
+});

src/application/variable/PopstateQueue.test.ts

@@ -0,0 +1,26 @@
+import { popstateQueue, setPopstateQueue } from "./PopstateQueue";
+import { describe, expect, it } from "vitest";
+
+describe("PopstateQueue Test", () =>
+{
+    it("popstateQueue should be a resolved Promise initially", async () =>
+    {
+        const result = await popstateQueue;
+        expect(result).toBeUndefined();
+    });
+
+    it("setPopstateQueue should update the popstateQueue", async () =>
+    {
+        let executed = false;
+        const newQueue = Promise.resolve().then(() =>
+        {
+            executed = true;
+        });
+
+        setPopstateQueue(newQueue);
+
+        await popstateQueue;
+
+        expect(executed).toBe(true);
+    });
+});

src/domain/entity/DefaultLoader.test.ts

@@ -235,4 +235,60 @@ describe("DefaultLoader Test", () =>
             expect(sprite).toBe(loader.sprite);
         });
     });
+
+    describe("edge cases", () =>
+    {
+        it("start should handle null shape gracefully when sprite children are removed", () =>
+        {
+            const root = new MovieClip();
+            $setContext(new Context(root));
+
+            const loader = new DefaultLoader();
+            // Remove all children to trigger the null check
+            while (loader.sprite.numChildren > 0) {
+                loader.sprite.removeChildAt(0);
+            }
+
+            // Should not throw
+            loader.start();
+        });
+
+        it("end should handle null shape gracefully when sprite children are removed", () =>
+        {
+            const root = new MovieClip();
+            $setContext(new Context(root));
+
+            const loader = new DefaultLoader();
+            root.addChild(loader.sprite);
+
+            // Remove all children from sprite
+            while (loader.sprite.numChildren > 0) {
+                loader.sprite.removeChildAt(0);
+            }
+
+            // Should not throw
+            loader.end();
+
+            expect(root.numChildren).toBe(0);
+        });
+
+        it("start should skip redrawing when shape width matches minSize", () =>
+        {
+            const root = new MovieClip();
+            $setContext(new Context(root));
+
+            const loader = new DefaultLoader();
+
+            // First start - shapes are drawn
+            loader.start();
+
+            // Get the first shape's width after drawing
+            const shape0 = loader.sprite.getChildAt<Shape>(0);
+            expect(shape0).toBeTruthy();
+
+            // Second start - should skip the redraw branch (line 175)
+            // because shape.width === minSize is already true
+            loader.start();
+        });
+    });
 });