@plures/praxis 1.0.3 → 1.1.1

package/src/__tests__/actors.test.ts

@@ -2,14 +2,14 @@
  * Actor system tests
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ActorManager, createTimerActor, type Actor } from "../core/actors.js";
-import { createPraxisEngine } from "../core/engine.js";
-import { PraxisRegistry } from "../core/rules.js";
-import { defineEvent, defineRule, defineFact } from "../dsl/index.js";
-
-describe("Actor System", () => {
-  describe("ActorManager", () => {
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ActorManager, createTimerActor, type Actor } from '../core/actors.js';
+import { createPraxisEngine } from '../core/engine.js';
+import { PraxisRegistry } from '../core/rules.js';
+import { defineEvent, defineRule, defineFact } from '../dsl/index.js';
+
+describe('Actor System', () => {
+  describe('ActorManager', () => {
     let manager: ActorManager<{ count: number }>;
     let registry: PraxisRegistry<{ count: number }>;
     let engine: ReturnType<typeof createPraxisEngine<{ count: number }>>;
@@ -24,68 +24,68 @@ describe("Actor System", () => {
       manager.attachEngine(engine);
     });
 
-    it("should register and start an actor", async () => {
+    it('should register and start an actor', async () => {
       const onStartSpy = vi.fn();
       const actor: Actor<{ count: number }> = {
-        id: "test-actor",
-        description: "Test actor",
+        id: 'test-actor',
+        description: 'Test actor',
         onStart: onStartSpy,
       };
 
       manager.register(actor);
-      await manager.start("test-actor");
+      await manager.start('test-actor');
 
       expect(onStartSpy).toHaveBeenCalledWith(engine);
-      expect(manager.isActive("test-actor")).toBe(true);
+      expect(manager.isActive('test-actor')).toBe(true);
     });
 
-    it("should throw when registering duplicate actor IDs", () => {
+    it('should throw when registering duplicate actor IDs', () => {
       const actor: Actor<{ count: number }> = {
-        id: "duplicate",
-        description: "Test actor",
+        id: 'duplicate',
+        description: 'Test actor',
       };
 
       manager.register(actor);
       expect(() => manager.register(actor)).toThrow('Actor with id "duplicate" already registered');
     });
 
-    it("should throw when starting already active actor", async () => {
+    it('should throw when starting already active actor', async () => {
       const actor: Actor<{ count: number }> = {
-        id: "test",
-        description: "Test",
+        id: 'test',
+        description: 'Test',
       };
 
       manager.register(actor);
-      await manager.start("test");
-      await expect(manager.start("test")).rejects.toThrow('Actor "test" is already started');
+      await manager.start('test');
+      await expect(manager.start('test')).rejects.toThrow('Actor "test" is already started');
     });
 
-    it("should stop an actor", async () => {
+    it('should stop an actor', async () => {
       const onStopSpy = vi.fn();
       const actor: Actor<{ count: number }> = {
-        id: "test-actor",
-        description: "Test actor",
+        id: 'test-actor',
+        description: 'Test actor',
         onStop: onStopSpy,
       };
 
       manager.register(actor);
-      await manager.start("test-actor");
-      await manager.stop("test-actor");
+      await manager.start('test-actor');
+      await manager.stop('test-actor');
 
       expect(onStopSpy).toHaveBeenCalled();
-      expect(manager.isActive("test-actor")).toBe(false);
+      expect(manager.isActive('test-actor')).toBe(false);
     });
 
-    it("should notify actors of state changes", async () => {
+    it('should notify actors of state changes', async () => {
       const onStateChangeSpy = vi.fn();
       const actor: Actor<{ count: number }> = {
-        id: "observer",
-        description: "Observer actor",
+        id: 'observer',
+        description: 'Observer actor',
         onStateChange: onStateChangeSpy,
       };
 
       manager.register(actor);
-      await manager.start("observer");
+      await manager.start('observer');
 
       const state = engine.getState();
       await manager.notifyStateChange(state);
@@ -93,12 +93,12 @@ describe("Actor System", () => {
       expect(onStateChangeSpy).toHaveBeenCalledWith(state, engine);
     });
 
-    it("should start all registered actors", async () => {
+    it('should start all registered actors', async () => {
       const onStart1 = vi.fn();
       const onStart2 = vi.fn();
 
-      manager.register({ id: "actor1", description: "Actor 1", onStart: onStart1 });
-      manager.register({ id: "actor2", description: "Actor 2", onStart: onStart2 });
+      manager.register({ id: 'actor1', description: 'Actor 1', onStart: onStart1 });
+      manager.register({ id: 'actor2', description: 'Actor 2', onStart: onStart2 });
 
       await manager.startAll();
 
@@ -107,12 +107,12 @@ describe("Actor System", () => {
       expect(manager.getActiveActorIds()).toHaveLength(2);
     });
 
-    it("should stop all active actors", async () => {
+    it('should stop all active actors', async () => {
       const onStop1 = vi.fn();
       const onStop2 = vi.fn();
 
-      manager.register({ id: "actor1", description: "Actor 1", onStop: onStop1 });
-      manager.register({ id: "actor2", description: "Actor 2", onStop: onStop2 });
+      manager.register({ id: 'actor1', description: 'Actor 1', onStop: onStop1 });
+      manager.register({ id: 'actor2', description: 'Actor 2', onStop: onStop2 });
 
       await manager.startAll();
       await manager.stopAll();
@@ -122,13 +122,13 @@ describe("Actor System", () => {
       expect(manager.getActiveActorIds()).toHaveLength(0);
     });
 
-    it("should handle async actor methods", async () => {
+    it('should handle async actor methods', async () => {
       let startResolved = false;
       let stopResolved = false;
 
       const actor: Actor<{ count: number }> = {
-        id: "async-actor",
-        description: "Async actor",
+        id: 'async-actor',
+        description: 'Async actor',
         onStart: async () => {
           await new Promise((resolve) => setTimeout(resolve, 10));
           startResolved = true;
@@ -140,24 +140,24 @@ describe("Actor System", () => {
       };
 
       manager.register(actor);
-      await manager.start("async-actor");
+      await manager.start('async-actor');
       expect(startResolved).toBe(true);
 
-      await manager.stop("async-actor");
+      await manager.stop('async-actor');
       expect(stopResolved).toBe(true);
     });
 
-    it("should not notify stopped actors of state changes", async () => {
+    it('should not notify stopped actors of state changes', async () => {
       const onStateChangeSpy = vi.fn();
       const actor: Actor<{ count: number }> = {
-        id: "observer",
-        description: "Observer",
+        id: 'observer',
+        description: 'Observer',
         onStateChange: onStateChangeSpy,
       };
 
       manager.register(actor);
-      await manager.start("observer");
-      await manager.stop("observer");
+      await manager.start('observer');
+      await manager.stop('observer');
 
       const state = engine.getState();
       await manager.notifyStateChange(state);
@@ -165,31 +165,31 @@ describe("Actor System", () => {
       expect(onStateChangeSpy).not.toHaveBeenCalled();
     });
 
-    it("should throw when starting actor without attached engine", async () => {
+    it('should throw when starting actor without attached engine', async () => {
       const actor: Actor<{ count: number }> = {
-        id: "test",
-        description: "Test",
+        id: 'test',
+        description: 'Test',
       };
 
       const newManager = new ActorManager<{ count: number }>();
       newManager.register(actor);
 
-      await expect(newManager.start("test")).rejects.toThrow(
-        "Actor manager not attached to an engine"
+      await expect(newManager.start('test')).rejects.toThrow(
+        'Actor manager not attached to an engine'
       );
     });
   });
 
-  describe("createTimerActor", () => {
-    it("should create a timer actor that dispatches events", async () => {
+  describe('createTimerActor', () => {
+    it('should create a timer actor that dispatches events', async () => {
       vi.useFakeTimers();
 
-      const Tick = defineEvent<"TICK", {}>("TICK");
-      const TickReceived = defineFact<"TickReceived", {}>("TickReceived");
+      const Tick = defineEvent<'TICK', {}>('TICK');
+      const TickReceived = defineFact<'TickReceived', {}>('TickReceived');
 
       const tickRule = defineRule<{ count: number }>({
-        id: "tick.rule",
-        description: "Count ticks",
+        id: 'tick.rule',
+        description: 'Count ticks',
         impl: (state, events) => {
           if (events.some(Tick.is)) {
             state.context.count += 1;
@@ -210,9 +210,9 @@ describe("Actor System", () => {
       const manager = new ActorManager<{ count: number }>();
       manager.attachEngine(engine);
 
-      const timerActor = createTimerActor("timer", 100, () => Tick.create({}));
+      const timerActor = createTimerActor('timer', 100, () => Tick.create({}));
       manager.register(timerActor);
-      await manager.start("timer");
+      await manager.start('timer');
 
       // Advance timers
       vi.advanceTimersByTime(250);
@@ -220,19 +220,19 @@ describe("Actor System", () => {
       // Should have ticked at least twice (at 100ms and 200ms)
       expect(engine.getContext().count).toBeGreaterThanOrEqual(2);
 
-      await manager.stop("timer");
+      await manager.stop('timer');
       vi.useRealTimers();
     });
 
-    it("should stop dispatching events after actor is stopped", async () => {
+    it('should stop dispatching events after actor is stopped', async () => {
       vi.useFakeTimers();
 
-      const Tick = defineEvent<"TICK", {}>("TICK");
+      const Tick = defineEvent<'TICK', {}>('TICK');
       const registry = new PraxisRegistry<{ count: number }>();
 
       const tickRule = defineRule<{ count: number }>({
-        id: "tick.rule",
-        description: "Count ticks",
+        id: 'tick.rule',
+        description: 'Count ticks',
         impl: (state, events) => {
           if (events.some(Tick.is)) {
             state.context.count += 1;
@@ -250,14 +250,14 @@ describe("Actor System", () => {
       const manager = new ActorManager<{ count: number }>();
       manager.attachEngine(engine);
 
-      const timerActor = createTimerActor("timer", 50, () => Tick.create({}));
+      const timerActor = createTimerActor('timer', 50, () => Tick.create({}));
       manager.register(timerActor);
-      await manager.start("timer");
+      await manager.start('timer');
 
       vi.advanceTimersByTime(100);
       const countBeforeStop = engine.getContext().count;
 
-      await manager.stop("timer");
+      await manager.stop('timer');
       vi.advanceTimersByTime(200);
       const countAfterStop = engine.getContext().count;
 

package/src/__tests__/billing.test.ts

@@ -1,10 +1,10 @@
 /**
  * Billing Tests
- * 
+ *
  * Tests for billing types and utilities.
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   SubscriptionTier,
   SubscriptionStatus,
@@ -14,18 +14,18 @@ import {
   checkUsageLimits,
   createFreeSubscription,
   createSponsorSubscription,
-} from "../cloud/billing.js";
+} from '../cloud/billing.js';
 
-describe("Billing", () => {
-  describe("Tier Limits", () => {
-    it("should have limits for all tiers", () => {
+describe('Billing', () => {
+  describe('Tier Limits', () => {
+    it('should have limits for all tiers', () => {
       expect(TIER_LIMITS[SubscriptionTier.FREE]).toBeDefined();
       expect(TIER_LIMITS[SubscriptionTier.SOLO]).toBeDefined();
       expect(TIER_LIMITS[SubscriptionTier.TEAM]).toBeDefined();
       expect(TIER_LIMITS[SubscriptionTier.ENTERPRISE]).toBeDefined();
     });
 
-    it("should have increasing limits for higher tiers", () => {
+    it('should have increasing limits for higher tiers', () => {
       expect(TIER_LIMITS[SubscriptionTier.SOLO].maxSyncsPerMonth).toBeGreaterThan(
         TIER_LIMITS[SubscriptionTier.FREE].maxSyncsPerMonth
       );
@@ -38,13 +38,13 @@ describe("Billing", () => {
     });
   });
 
-  describe("hasAccessToTier", () => {
-    it("should grant access to same tier", () => {
+  describe('hasAccessToTier', () => {
+    it('should grant access to same tier', () => {
       const subscription = createFreeSubscription();
       expect(hasAccessToTier(subscription, SubscriptionTier.FREE)).toBe(true);
     });
 
-    it("should grant access to lower tiers", () => {
+    it('should grant access to lower tiers', () => {
       const subscription = {
         ...createFreeSubscription(),
         tier: SubscriptionTier.ENTERPRISE,
@@ -54,14 +54,14 @@ describe("Billing", () => {
       expect(hasAccessToTier(subscription, SubscriptionTier.TEAM)).toBe(true);
     });
 
-    it("should deny access to higher tiers", () => {
+    it('should deny access to higher tiers', () => {
       const subscription = createFreeSubscription();
       expect(hasAccessToTier(subscription, SubscriptionTier.SOLO)).toBe(false);
       expect(hasAccessToTier(subscription, SubscriptionTier.TEAM)).toBe(false);
       expect(hasAccessToTier(subscription, SubscriptionTier.ENTERPRISE)).toBe(false);
     });
 
-    it("should deny access if subscription is not active", () => {
+    it('should deny access if subscription is not active', () => {
       const subscription = {
         ...createFreeSubscription(),
         status: SubscriptionStatus.EXPIRED,
@@ -70,8 +70,8 @@ describe("Billing", () => {
     });
   });
 
-  describe("checkUsageLimits", () => {
-    it("should pass when usage is within limits", () => {
+  describe('checkUsageLimits', () => {
+    it('should pass when usage is within limits', () => {
       const subscription = createFreeSubscription();
       const result = checkUsageLimits(subscription, {
         syncCount: 500,
@@ -83,7 +83,7 @@ describe("Billing", () => {
       expect(result.violations).toHaveLength(0);
     });
 
-    it("should fail when sync count exceeds limit", () => {
+    it('should fail when sync count exceeds limit', () => {
       const subscription = createFreeSubscription();
       const result = checkUsageLimits(subscription, {
         syncCount: 2000,
@@ -93,10 +93,10 @@ describe("Billing", () => {
       });
       expect(result.withinLimits).toBe(false);
       expect(result.violations.length).toBeGreaterThan(0);
-      expect(result.violations[0]).toContain("Sync limit exceeded");
+      expect(result.violations[0]).toContain('Sync limit exceeded');
     });
 
-    it("should fail when storage exceeds limit", () => {
+    it('should fail when storage exceeds limit', () => {
       const subscription = createFreeSubscription();
       const result = checkUsageLimits(subscription, {
         syncCount: 0,
@@ -106,10 +106,10 @@ describe("Billing", () => {
       });
       expect(result.withinLimits).toBe(false);
       expect(result.violations.length).toBeGreaterThan(0);
-      expect(result.violations[0]).toContain("Storage limit exceeded");
+      expect(result.violations[0]).toContain('Storage limit exceeded');
     });
 
-    it("should fail when team members exceed limit", () => {
+    it('should fail when team members exceed limit', () => {
       const subscription = createFreeSubscription();
       const result = checkUsageLimits(subscription, {
         syncCount: 0,
@@ -119,10 +119,10 @@ describe("Billing", () => {
       });
       expect(result.withinLimits).toBe(false);
       expect(result.violations.length).toBeGreaterThan(0);
-      expect(result.violations[0]).toContain("Team member limit exceeded");
+      expect(result.violations[0]).toContain('Team member limit exceeded');
     });
 
-    it("should allow unlimited team members for enterprise", () => {
+    it('should allow unlimited team members for enterprise', () => {
       const subscription = {
         ...createFreeSubscription(),
         tier: SubscriptionTier.ENTERPRISE,
@@ -138,8 +138,8 @@ describe("Billing", () => {
     });
   });
 
-  describe("createFreeSubscription", () => {
-    it("should create a free subscription", () => {
+  describe('createFreeSubscription', () => {
+    it('should create a free subscription', () => {
       const subscription = createFreeSubscription();
       expect(subscription.tier).toBe(SubscriptionTier.FREE);
       expect(subscription.status).toBe(SubscriptionStatus.ACTIVE);
@@ -148,27 +148,27 @@ describe("Billing", () => {
     });
   });
 
-  describe("createSponsorSubscription", () => {
-    it("should create solo tier for $5/month", () => {
-      const subscription = createSponsorSubscription("Solo", 500);
+  describe('createSponsorSubscription', () => {
+    it('should create solo tier for $5/month', () => {
+      const subscription = createSponsorSubscription('Solo', 500);
       expect(subscription.tier).toBe(SubscriptionTier.SOLO);
       expect(subscription.provider).toBe(BillingProvider.SPONSORS);
     });
 
-    it("should create team tier for $20/month", () => {
-      const subscription = createSponsorSubscription("Team", 2000);
+    it('should create team tier for $20/month', () => {
+      const subscription = createSponsorSubscription('Team', 2000);
       expect(subscription.tier).toBe(SubscriptionTier.TEAM);
       expect(subscription.provider).toBe(BillingProvider.SPONSORS);
     });
 
-    it("should create enterprise tier for $50/month", () => {
-      const subscription = createSponsorSubscription("Enterprise", 5000);
+    it('should create enterprise tier for $50/month', () => {
+      const subscription = createSponsorSubscription('Enterprise', 5000);
       expect(subscription.tier).toBe(SubscriptionTier.ENTERPRISE);
       expect(subscription.provider).toBe(BillingProvider.SPONSORS);
     });
 
-    it("should default to free tier for low amounts", () => {
-      const subscription = createSponsorSubscription("Supporter", 100);
+    it('should default to free tier for low amounts', () => {
+      const subscription = createSponsorSubscription('Supporter', 100);
       expect(subscription.tier).toBe(SubscriptionTier.FREE);
     });
   });