@epsilon-asi/actors 0.0.22 → 0.0.32

package/tests/unit/native/NativeWindowService.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { DefaultNativeWindowService } from '../../../src/native/NativeWindowService.js';
+import type { NativeScreenDriver, NativeWindowDriver, NativeWindowHandle } from '../../../src/native/drivers.js';
+import type { NativePoint, NativeSize, NativeWindowInfo } from '../../../src/native/types.js';
+
+class FakeWindowHandle implements NativeWindowHandle {
+  focusCalls = 0;
+  minimizeCalls = 0;
+  restoreCalls = 0;
+  moveCalls: NativePoint[] = [];
+  resizeCalls: NativeSize[] = [];
+  setFullscreenCalls: boolean[] = [];
+  toggleFullscreenCalls = 0;
+
+  constructor(private current: NativeWindowInfo) {}
+
+  async info(): Promise<NativeWindowInfo> { return this.current; }
+  async focus(): Promise<void> { this.focusCalls += 1; this.current = { ...this.current, isFocused: true }; }
+  async minimize(): Promise<void> { this.minimizeCalls += 1; this.current = { ...this.current, isMinimized: true }; }
+  async restore(): Promise<void> { this.restoreCalls += 1; this.current = { ...this.current, isMinimized: false }; }
+  async move(point: NativePoint): Promise<void> { this.moveCalls.push(point); this.current = { ...this.current, region: { ...this.current.region, ...point } }; }
+  async resize(size: NativeSize): Promise<void> { this.resizeCalls.push(size); this.current = { ...this.current, region: { ...this.current.region, ...size } }; }
+  async setFullscreen(fullscreen: boolean): Promise<void> { this.setFullscreenCalls.push(fullscreen); this.current = { ...this.current, isFullscreen: fullscreen }; }
+  async toggleFullscreen(): Promise<void> { this.toggleFullscreenCalls += 1; }
+}
+
+class FakeWindowDriver implements NativeWindowDriver {
+  constructor(readonly handles: FakeWindowHandle[]) {}
+  async list(): Promise<NativeWindowHandle[]> { return this.handles; }
+}
+
+class FakeScreenDriver implements NativeScreenDriver {
+  async width(): Promise<number> { return 500; }
+  async height(): Promise<number> { return 400; }
+}
+
+describe('DefaultNativeWindowService', () => {
+  it('detects whether a matching window is open', async () => {
+    const handle = new FakeWindowHandle({ title: 'Upwork', appName: 'Google Chrome', region: { x: 0, y: 0, width: 100, height: 100 } });
+    const service = new DefaultNativeWindowService({ driver: new FakeWindowDriver([handle]), screen: new FakeScreenDriver() });
+
+    await expect(service.isOpen({ title: 'Upwork' })).resolves.toBe(true);
+    await expect(service.isOpen({ title: 'Other' })).resolves.toBe(false);
+  });
+
+  it('restores, focuses, and moves an off-screen window into view', async () => {
+    const handle = new FakeWindowHandle({ title: 'Chrome', isMinimized: true, region: { x: -900, y: -800, width: 200, height: 150 } });
+    const service = new DefaultNativeWindowService({ driver: new FakeWindowDriver([handle]), screen: new FakeScreenDriver() });
+
+    const info = await service.ensureInView({ title: 'Chrome' });
+
+    expect(handle.restoreCalls).toBe(1);
+    expect(handle.focusCalls).toBe(1);
+    expect(handle.moveCalls).toEqual([{ x: 0, y: 0 }]);
+    expect(info.region).toMatchObject({ x: 0, y: 0 });
+  });
+
+  it('does not toggle fullscreen when the requested state already matches', async () => {
+    const handle = new FakeWindowHandle({ title: 'Chrome', isFullscreen: true, region: { x: 0, y: 0, width: 500, height: 400 } });
+    const service = new DefaultNativeWindowService({ driver: new FakeWindowDriver([handle]), screen: new FakeScreenDriver() });
+
+    await service.setFullscreen({ title: 'Chrome' }, true);
+
+    expect(handle.setFullscreenCalls).toEqual([]);
+    expect(handle.toggleFullscreenCalls).toBe(0);
+  });
+
+  it('sets fullscreen through the handle when state differs', async () => {
+    const handle = new FakeWindowHandle({ title: 'Chrome', isFullscreen: false, region: { x: 0, y: 0, width: 500, height: 400 } });
+    const service = new DefaultNativeWindowService({ driver: new FakeWindowDriver([handle]), screen: new FakeScreenDriver() });
+
+    await service.setFullscreen({ title: 'Chrome' }, true);
+
+    expect(handle.setFullscreenCalls).toEqual([true]);
+  });
+
+  it('minimizes via the native minimize operation instead of fullscreen toggle', async () => {
+    const handle = new FakeWindowHandle({ title: 'Chrome', isFullscreen: true, region: { x: 0, y: 0, width: 500, height: 400 } });
+    const service = new DefaultNativeWindowService({ driver: new FakeWindowDriver([handle]), screen: new FakeScreenDriver() });
+
+    await service.minimize({ title: 'Chrome' });
+
+    expect(handle.minimizeCalls).toBe(1);
+    expect(handle.setFullscreenCalls).toEqual([]);
+    expect(handle.toggleFullscreenCalls).toBe(0);
+  });
+});

package/tests/unit/native/WindowMatcher.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { matchesWindow, matcherToString } from '../../../src/native/WindowMatcher.js';
+import type { NativeWindowInfo } from '../../../src/native/types.js';
+
+const windowInfo: NativeWindowInfo = {
+  title: 'Upwork - Google Chrome',
+  appName: 'Google Chrome',
+  bundleId: 'com.google.Chrome',
+  role: 'AXWindow',
+  region: { x: 0, y: 0, width: 1200, height: 800 }
+};
+
+describe('WindowMatcher', () => {
+  it('matches exact title, app name, bundle id, role, includes, and regex', () => {
+    expect(matchesWindow(windowInfo, { title: 'Upwork - Google Chrome' })).toBe(true);
+    expect(matchesWindow(windowInfo, { appName: 'Google Chrome', titleIncludes: 'Upwork' })).toBe(true);
+    expect(matchesWindow(windowInfo, { bundleId: 'com.google.Chrome', role: 'AXWindow' })).toBe(true);
+    expect(matchesWindow(windowInfo, { titleRegex: /Upwork/ })).toBe(true);
+    expect(matchesWindow(windowInfo, { titleRegex: 'Google Chrome$' })).toBe(true);
+  });
+
+  it('rejects non-matching window attributes', () => {
+    expect(matchesWindow(windowInfo, { appName: 'Safari' })).toBe(false);
+    expect(matchesWindow(windowInfo, { titleIncludes: 'LinkedIn' })).toBe(false);
+    expect(matchesWindow(windowInfo, { titleRegex: /^Safari/ })).toBe(false);
+  });
+
+  it('summarizes matchers for diagnostics', () => {
+    expect(matcherToString({ appName: 'Google Chrome', titleIncludes: 'Upwork' })).toBe('app=Google Chrome, titleIncludes=Upwork');
+    expect(matcherToString({})).toBe('<any window>');
+  });
+});

package/tests/unit/native/appleScriptEscape.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import { appleScriptString } from '../../../src/native/utils/appleScriptEscape.js';
+
+describe('appleScriptString', () => {
+  it('escapes quotes, backslashes, spaces, apostrophes, and unicode safely', () => {
+    expect(appleScriptString('/Users/me/A "quoted" \\ file’s résumé.pdf'))
+      .toBe('"/Users/me/A \\"quoted\\" \\\\ file’s résumé.pdf"');
+  });
+});

package/tests/unit/sites/myvistage-com.login.test.ts

@@ -8,7 +8,7 @@ describe('myvistage-com actor login flow', () => {
 
     expect(auth).toBeDefined();
     expect(auth?.loginUrl).toBe('https://myvistage.com');
-    expect(auth?.credentials).toEqual({ id: 'myvistage-com' });
+    expect(auth?.credentials).toEqual({ id: 'myvistage_com' });
     expect(auth?.selectors).toEqual(myvistageComSelectors.login);
     expect(auth?.steps).toBeUndefined();
   });

package/tests/unit/sites/myvistage-com.postComment.test.ts

@@ -20,7 +20,6 @@ describe('myvistage-com actor postComment task', () => {
       subject: 'Quick follow-up'
     });
 
-    expect(fakePage.gotos[0]?.url).toBe('https://myvistage.com/?status/151341-151341-1779377493/');
     expect(fakeInteractor.typed).toEqual([
       {
         selector: myvistageComSelectors.postComment.comment,

package/tests/unit/sites/upwork-com.login.test.ts

@@ -7,7 +7,7 @@ describe('upwork-com actor login flow', () => {
     const auth = upworkComActor.auth;
 
     expect(auth).toBeDefined();
-    expect(auth?.loginUrl).toBe('https://www.upwork.com/ab/account-security/login');
+
     expect(auth?.credentials).toEqual({ id: 'upwork' });
     expect(auth?.selectors.loggedInSignal).toBe(upworkComSelectors.login.loggedInSignal);
     expect(auth?.selectors.errorMessage).toBe(upworkComSelectors.login.errorMessage);