@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

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

@@ -1,595 +0,0 @@
-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)
-		})
-	})
-})