@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/src/core/plugins/__tests__/registry.test.ts

@@ -0,0 +1,595 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { BasePlugin } from "../base-plugin"
+import { PluginRegistry } from "../registry"
+import type { PluginConfig, PluginContext, PluginMetadata } from "../types"
+
+// Mock plugin for testing
+class TestPlugin extends BasePlugin {
+	onInitializeCalled = false
+	onActivateCalled = false
+	onDeactivateCalled = false
+	onDestroyCalled = false
+
+	protected onInitialize(): void {
+		this.onInitializeCalled = true
+	}
+
+	protected onActivate(): void {
+		this.onActivateCalled = true
+	}
+
+	protected onDeactivate(): void {
+		this.onDeactivateCalled = true
+	}
+
+	protected onDestroy(): void {
+		this.onDestroyCalled = true
+	}
+}
+
+class AnalyticsPlugin extends BasePlugin {
+	protected onInitialize(): void {}
+	protected onActivate(): void {}
+	protected onDeactivate(): void {}
+}
+
+class CustomControlsPlugin extends BasePlugin {
+	protected onInitialize(): void {}
+	protected onActivate(): void {}
+	protected onDeactivate(): void {}
+}
+
+describe.sequential("PluginRegistry", () => {
+	let registry: PluginRegistry
+	let mockContext: PluginContext
+
+	beforeEach(() => {
+		registry = new PluginRegistry()
+		mockContext = {
+			state: {
+				isPlaying: false,
+				currentTime: 0,
+				duration: 100,
+				volume: 1,
+				isMuted: false
+			} as any,
+			controls: {
+				play: vi.fn(),
+				pause: vi.fn(),
+				seek: vi.fn()
+			} as any,
+			element: document.createElement("video"),
+			plugins: registry,
+			logger: {
+				info: vi.fn(),
+				warn: vi.fn(),
+				error: vi.fn()
+			} as any,
+			emit: vi.fn(),
+			on: vi.fn()
+		}
+	})
+
+	describe("Plugin Registration", () => {
+		it("should register a plugin", () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+
+			expect(registry.has("test")).toBe(true)
+			expect(registry.get("test")).toBe(plugin)
+		})
+
+		it("should throw error when registering duplicate plugin", () => {
+			const plugin1 = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			const plugin2 = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin1)
+
+			expect(() => registry.register("test", plugin2)).toThrow()
+		})
+
+		it("should register multiple plugins", () => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal"
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "analytics",
+				priority: "high"
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+
+			expect(registry.has("plugin1")).toBe(true)
+			expect(registry.has("plugin2")).toBe(true)
+			expect(registry.getAll()).toHaveLength(2)
+		})
+	})
+
+	describe("Plugin Unregistration", () => {
+		it("should unregister a plugin", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+			await registry.initialize("test", mockContext)
+			await registry.activate("test", mockContext)
+
+			await registry.unregister("test", mockContext)
+
+			expect(registry.has("test")).toBe(false)
+			expect(plugin.onDestroyCalled).toBe(true)
+		})
+
+		it("should throw error when unregistering non-existent plugin", async () => {
+			await expect(registry.unregister("non-existent", mockContext)).rejects.toThrow()
+		})
+	})
+
+	describe("Plugin Lifecycle", () => {
+		it("should initialize a plugin", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+			await registry.initialize("test", mockContext, { debug: true })
+
+			expect(plugin.onInitializeCalled).toBe(true)
+			expect(plugin.isInitialized).toBe(true)
+		})
+
+		it("should activate a plugin", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+			await registry.initialize("test", mockContext)
+			await registry.activate("test", mockContext)
+
+			expect(plugin.onActivateCalled).toBe(true)
+			expect(plugin.isActive).toBe(true)
+		})
+
+		it("should deactivate a plugin", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+			await registry.initialize("test", mockContext)
+			await registry.activate("test", mockContext)
+			await registry.deactivate("test", mockContext)
+
+			expect(plugin.onDeactivateCalled).toBe(true)
+			expect(plugin.isActive).toBe(false)
+		})
+
+		it("should require initialization before activation", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+
+			await expect(registry.activate("test", mockContext)).rejects.toThrow()
+		})
+	})
+
+	describe("Plugin Dependencies", () => {
+		it("should handle plugin dependencies", async () => {
+			const basePlugin = new TestPlugin({
+				name: "base-plugin",
+				category: "ui",
+				priority: "high"
+			})
+
+			const dependentPlugin = new AnalyticsPlugin({
+				name: "dependent-plugin",
+				category: "analytics",
+				priority: "normal",
+				dependencies: ["base"]
+			})
+
+			registry.register("base", basePlugin)
+			registry.register("dependent", dependentPlugin)
+
+			await registry.initialize("base", mockContext)
+			await registry.activate("base", mockContext)
+
+			await registry.initialize("dependent", mockContext)
+			await registry.activate("dependent", mockContext)
+
+			expect(basePlugin.isActive).toBe(true)
+			expect(dependentPlugin.isActive).toBe(true)
+		})
+
+		it("should detect circular dependencies", () => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal",
+				dependencies: ["plugin2"]
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "analytics",
+				priority: "normal",
+				dependencies: ["plugin1"]
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+
+			// Should detect and handle circular dependency
+			expect(() => registry.validateDependencies()).toThrow(/circular/i)
+		})
+
+		it("should throw error when dependency is missing", async () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal",
+				dependencies: ["missing-plugin"]
+			})
+
+			registry.register("test", plugin)
+
+			await expect(registry.initialize("test", mockContext)).rejects.toThrow()
+		})
+	})
+
+	describe("Plugin Conflicts", () => {
+		it("should detect plugin conflicts", () => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal",
+				conflicts: ["plugin2"]
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+
+			expect(() => registry.validateConflicts()).toThrow(/conflict/i)
+		})
+
+		it("should allow non-conflicting plugins", () => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal"
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "analytics",
+				priority: "normal"
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+
+			expect(() => registry.validateConflicts()).not.toThrow()
+		})
+	})
+
+	describe("Plugin Priority", () => {
+		it("should activate plugins in priority order", async () => {
+			const activationOrder: string[] = []
+
+			class TrackingPlugin extends BasePlugin {
+				constructor(
+					metadata: PluginMetadata,
+					private trackingName: string
+				) {
+					super(metadata)
+				}
+
+				protected onInitialize(): void {}
+
+				protected onActivate(): void {
+					activationOrder.push(this.trackingName)
+				}
+
+				protected onDeactivate(): void {}
+			}
+
+			const highPriorityPlugin = new TrackingPlugin(
+				{
+					name: "high-priority",
+					category: "ui",
+					priority: "high"
+				},
+				"high"
+			)
+
+			const normalPriorityPlugin = new TrackingPlugin(
+				{
+					name: "normal-priority",
+					category: "ui",
+					priority: "normal"
+				},
+				"normal"
+			)
+
+			const lowPriorityPlugin = new TrackingPlugin(
+				{
+					name: "low-priority",
+					category: "ui",
+					priority: "low"
+				},
+				"low"
+			)
+
+			registry.register("high", highPriorityPlugin)
+			registry.register("normal", normalPriorityPlugin)
+			registry.register("low", lowPriorityPlugin)
+
+			await registry.initialize("high", mockContext)
+			await registry.initialize("normal", mockContext)
+			await registry.initialize("low", mockContext)
+
+			await registry.activateAll(mockContext)
+
+			expect(activationOrder).toEqual(["high", "normal", "low"])
+		})
+	})
+
+	describe("Plugin Health Checks", () => {
+		it("should run health check on plugin", () => {
+			const plugin = new TestPlugin({
+				name: "test-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("test", plugin)
+
+			const isHealthy = registry.healthCheck("test")
+			expect(isHealthy).toBe(false) // Not initialized yet
+
+			plugin.onInitializeCalled = true
+			expect(registry.healthCheck("test")).toBe(true)
+		})
+
+		it("should run health check on all plugins", async () => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal"
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "analytics",
+				priority: "normal"
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+
+			await registry.initialize("plugin1", mockContext)
+			await registry.initialize("plugin2", mockContext)
+
+			const healthStatus = registry.healthCheckAll()
+
+			expect(healthStatus.plugin1).toBe(true)
+			expect(healthStatus.plugin2).toBe(true)
+		})
+	})
+
+	describe("Plugin Queries", () => {
+		beforeEach(async () => {
+			const plugin1 = new TestPlugin({
+				name: "test-ui-plugin",
+				category: "ui",
+				priority: "high"
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "analytics-plugin",
+				category: "analytics",
+				priority: "normal"
+			})
+
+			const plugin3 = new CustomControlsPlugin({
+				name: "controls-plugin",
+				category: "ui",
+				priority: "low"
+			})
+
+			registry.register("test-ui", plugin1)
+			registry.register("analytics", plugin2)
+			registry.register("controls", plugin3)
+
+			await registry.initialize("test-ui", mockContext)
+			await registry.initialize("analytics", mockContext)
+		})
+
+		it("should get all plugins", () => {
+			const plugins = registry.getAll()
+			expect(plugins).toHaveLength(3)
+		})
+
+		it("should get plugins by category", () => {
+			const uiPlugins = registry.getByCategory("ui")
+			expect(uiPlugins).toHaveLength(2)
+
+			const analyticsPlugins = registry.getByCategory("analytics")
+			expect(analyticsPlugins).toHaveLength(1)
+		})
+
+		it("should get active plugins", async () => {
+			await registry.activate("test-ui", mockContext)
+
+			const activePlugins = registry.getActive()
+			expect(activePlugins).toHaveLength(1)
+			expect(activePlugins[0].metadata.name).toBe("test-ui-plugin")
+		})
+
+		it("should check if plugin exists", () => {
+			expect(registry.has("test-ui")).toBe(true)
+			expect(registry.has("non-existent")).toBe(false)
+		})
+
+		it("should get plugin by name", () => {
+			const plugin = registry.get("test-ui")
+			expect(plugin).toBeDefined()
+			expect(plugin?.metadata.name).toBe("test-ui-plugin")
+		})
+	})
+
+	describe("Bulk Operations", () => {
+		beforeEach(() => {
+			const plugin1 = new TestPlugin({
+				name: "plugin1",
+				category: "ui",
+				priority: "normal"
+			})
+
+			const plugin2 = new AnalyticsPlugin({
+				name: "plugin2",
+				category: "analytics",
+				priority: "normal"
+			})
+
+			const plugin3 = new CustomControlsPlugin({
+				name: "plugin3",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("plugin1", plugin1)
+			registry.register("plugin2", plugin2)
+			registry.register("plugin3", plugin3)
+		})
+
+		it("should initialize all plugins", async () => {
+			await registry.initializeAll(mockContext)
+
+			const plugins = registry.getAll()
+			plugins.forEach((plugin) => {
+				expect(plugin.isInitialized).toBe(true)
+			})
+		})
+
+		it("should activate all plugins", async () => {
+			await registry.initializeAll(mockContext)
+			await registry.activateAll(mockContext)
+
+			const plugins = registry.getAll()
+			plugins.forEach((plugin) => {
+				expect(plugin.isActive).toBe(true)
+			})
+		})
+
+		it("should deactivate all plugins", async () => {
+			await registry.initializeAll(mockContext)
+			await registry.activateAll(mockContext)
+			await registry.deactivateAll(mockContext)
+
+			const plugins = registry.getAll()
+			plugins.forEach((plugin) => {
+				expect(plugin.isActive).toBe(false)
+			})
+		})
+
+		it("should destroy all plugins", async () => {
+			await registry.initializeAll(mockContext)
+			await registry.destroyAll(mockContext)
+
+			expect(registry.getAll()).toHaveLength(0)
+		})
+	})
+
+	describe("Error Handling", () => {
+		it("should handle plugin initialization errors", async () => {
+			class FailingPlugin extends BasePlugin {
+				protected onInitialize(): void {
+					throw new Error("Initialization failed")
+				}
+
+				protected onActivate(): void {}
+				protected onDeactivate(): void {}
+			}
+
+			const plugin = new FailingPlugin({
+				name: "failing-plugin",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("failing", plugin)
+
+			await expect(registry.initialize("failing", mockContext)).rejects.toThrow(
+				"Initialization failed"
+			)
+		})
+
+		it("should handle plugin activation errors", async () => {
+			class FailingActivationPlugin extends BasePlugin {
+				protected onInitialize(): void {}
+
+				protected onActivate(): void {
+					throw new Error("Activation failed")
+				}
+
+				protected onDeactivate(): void {}
+			}
+
+			const plugin = new FailingActivationPlugin({
+				name: "failing-activation",
+				category: "ui",
+				priority: "normal"
+			})
+
+			registry.register("failing", plugin)
+			await registry.initialize("failing", mockContext)
+
+			await expect(registry.activate("failing", mockContext)).rejects.toThrow("Activation failed")
+		})
+
+		it("should handle missing plugin gracefully", () => {
+			expect(registry.get("non-existent")).toBeUndefined()
+			expect(registry.has("non-existent")).toBe(false)
+		})
+	})
+})