635 lines
23 KiB
JavaScript
635 lines
23 KiB
JavaScript
// @ts-nocheck
|
|
/**
|
|
* tests/unit/foundry/FoundryAdapter.test.js
|
|
*
|
|
* Story 1.2 — WebRTC spike: FoundryAdapter probe tests.
|
|
* Story 1.3 — Data layer: constructor(game), surface delegation tests.
|
|
* Story 5.1 — Full AV Replacement: probeCapability returns 'stream-access', buildWebRTCSurface with full API
|
|
*
|
|
* OQ-1 spike result: css-fallback (FoundryVTT v14, 2026-05-21) - SUPERSEDED
|
|
* track.enabled = false does NOT stop inbound WebRTC bandwidth.
|
|
*
|
|
* NEW: probeCapability returns 'stream-access' when getMediaStreamForUser is available
|
|
* Full AV replacement architecture: hide Foundry dock, show VVM dock with actual video
|
|
*/
|
|
|
|
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
|
import { FoundryAdapter } from '../../../src/foundry/FoundryAdapter.js';
|
|
import {
|
|
GAME_STUB,
|
|
SETTINGS_STUB,
|
|
SOCKET_STUB,
|
|
USERS_STUB,
|
|
SCENES_STUB,
|
|
HOOKS_STUB,
|
|
UI_STUB,
|
|
GM_USER,
|
|
PLAYER_USER,
|
|
ACTIVE_SCENE,
|
|
} from '../../fixtures/foundry-adapter.js';
|
|
|
|
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Returns a minimal mock game.webrtc object whose client exposes getMediaStreamForUser.
|
|
* @param {MediaStream|null} [stream=null]
|
|
* @returns {{ client: { getMediaStreamForUser: import('vitest').MockedFunction<() => MediaStream|null> } }}
|
|
*/
|
|
function makeGameWebrtc(stream = null) {
|
|
return {
|
|
client: {
|
|
getMediaStreamForUser: vi.fn().mockReturnValue(stream),
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns a minimal MediaStream mock with one video track.
|
|
* @param {boolean} [enabled=true]
|
|
* @returns {{ getVideoTracks: import('vitest').MockedFunction<() => object[]>, _track: { enabled: boolean, kind: string } }}
|
|
*/
|
|
function makeStream(enabled = true) {
|
|
const track = { enabled, kind: 'video' };
|
|
return {
|
|
getVideoTracks: vi.fn().mockReturnValue([track]),
|
|
_track: track,
|
|
};
|
|
}
|
|
|
|
// ─── probeCapability ─────────────────────────────────────────────────────────
|
|
|
|
describe('FoundryAdapter.probeCapability', () => {
|
|
it('returns "unsupported" when gameWebrtc is null', () => {
|
|
expect(FoundryAdapter.probeCapability(null)).toBe('unsupported');
|
|
});
|
|
|
|
it('returns "unsupported" when gameWebrtc is undefined', () => {
|
|
expect(FoundryAdapter.probeCapability(undefined)).toBe('unsupported');
|
|
});
|
|
|
|
it('returns "unsupported" when gameWebrtc has no client', () => {
|
|
expect(FoundryAdapter.probeCapability({})).toBe('unsupported');
|
|
});
|
|
|
|
it('returns "unsupported" when client lacks getMediaStreamForUser', () => {
|
|
expect(FoundryAdapter.probeCapability({ client: {} })).toBe('unsupported');
|
|
});
|
|
|
|
it('returns "stream-access" when client has getMediaStreamForUser (Story 5.1 - Full AV Replacement)', () => {
|
|
// getMediaStreamForUser is available → full AV replacement is possible
|
|
const gameWebrtc = makeGameWebrtc();
|
|
expect(FoundryAdapter.probeCapability(gameWebrtc)).toBe('stream-access');
|
|
});
|
|
});
|
|
|
|
// ─── buildWebRTCSurface ───────────────────────────────────────────────────────
|
|
|
|
// Helper to create a full mock WebRTC client with all methods
|
|
function makeFullWebRTCClient(stream = null) {
|
|
return {
|
|
getMediaStreamForUser: vi.fn().mockReturnValue(stream),
|
|
getConnectedUsers: vi.fn().mockReturnValue(['user-1', 'user-2']),
|
|
getLevelsStreamForUser: vi.fn().mockReturnValue(stream),
|
|
isAudioEnabled: vi.fn().mockReturnValue(true),
|
|
isVideoEnabled: vi.fn().mockReturnValue(true),
|
|
toggleAudio: vi.fn(),
|
|
toggleVideo: vi.fn(),
|
|
toggleBroadcast: vi.fn(),
|
|
setUserVideo: vi.fn().mockResolvedValue(undefined),
|
|
};
|
|
}
|
|
|
|
function makeFullGameWebrtc(stream = null) {
|
|
return {
|
|
client: makeFullWebRTCClient(stream),
|
|
};
|
|
}
|
|
|
|
describe('FoundryAdapter.buildWebRTCSurface', () => {
|
|
let consoleWarnSpy;
|
|
let consoleErrorSpy;
|
|
|
|
beforeEach(() => {
|
|
consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
|
|
consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describe('returns complete WebRTC surface with 11 methods (Story 5.1)', () => {
|
|
it('returns object with all 11 WebRTC methods', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
expect(surface).toHaveProperty('getMediaStreamForUser');
|
|
expect(surface).toHaveProperty('getConnectedUsers');
|
|
expect(surface).toHaveProperty('getLevelsStreamForUser');
|
|
expect(surface).toHaveProperty('isAudioEnabled');
|
|
expect(surface).toHaveProperty('isVideoEnabled');
|
|
expect(surface).toHaveProperty('toggleAudio');
|
|
expect(surface).toHaveProperty('toggleVideo');
|
|
expect(surface).toHaveProperty('toggleBroadcast');
|
|
expect(surface).toHaveProperty('setUserVideo');
|
|
expect(surface).toHaveProperty('disableTrack');
|
|
expect(surface).toHaveProperty('enableTrack');
|
|
});
|
|
|
|
it('getMediaStreamForUser returns stream from client', () => {
|
|
const mockStream = new MediaStream();
|
|
const gameWebrtc = makeFullGameWebrtc(mockStream);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getMediaStreamForUser('user-1');
|
|
expect(result).toBe(mockStream);
|
|
expect(gameWebrtc.client.getMediaStreamForUser).toHaveBeenCalledWith('user-1');
|
|
});
|
|
|
|
it('getMediaStreamForUser returns null for invalid userId', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getMediaStreamForUser('');
|
|
expect(result).toBeNull();
|
|
expect(consoleWarnSpy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('getMediaStreamForUser returns null when client method throws', () => {
|
|
const gameWebrtc = {
|
|
client: {
|
|
getMediaStreamForUser: vi.fn().mockImplementation(() => {
|
|
throw new Error('AV error');
|
|
}),
|
|
},
|
|
};
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getMediaStreamForUser('user-1');
|
|
expect(result).toBeNull();
|
|
expect(consoleErrorSpy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('getConnectedUsers returns array from client', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getConnectedUsers();
|
|
expect(result).toEqual(['user-1', 'user-2']);
|
|
});
|
|
|
|
it('getConnectedUsers returns empty array on error', () => {
|
|
const gameWebrtc = {
|
|
client: {
|
|
getConnectedUsers: vi.fn().mockImplementation(() => {
|
|
throw new Error('Connection error');
|
|
}),
|
|
},
|
|
};
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getConnectedUsers();
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('isAudioEnabled delegates to client', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.isAudioEnabled();
|
|
expect(result).toBe(true);
|
|
expect(gameWebrtc.client.isAudioEnabled).toHaveBeenCalled();
|
|
});
|
|
|
|
it('isVideoEnabled delegates to client', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.isVideoEnabled();
|
|
expect(result).toBe(true);
|
|
expect(gameWebrtc.client.isVideoEnabled).toHaveBeenCalled();
|
|
});
|
|
|
|
it('toggleAudio calls client method with boolean', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.toggleAudio(true);
|
|
expect(gameWebrtc.client.toggleAudio).toHaveBeenCalledWith(true);
|
|
|
|
surface.toggleAudio(false);
|
|
expect(gameWebrtc.client.toggleAudio).toHaveBeenCalledWith(false);
|
|
});
|
|
|
|
it('toggleVideo calls client method with boolean', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.toggleVideo(true);
|
|
expect(gameWebrtc.client.toggleVideo).toHaveBeenCalledWith(true);
|
|
});
|
|
|
|
it('toggleBroadcast calls client method with boolean', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.toggleBroadcast(false);
|
|
expect(gameWebrtc.client.toggleBroadcast).toHaveBeenCalledWith(false);
|
|
});
|
|
|
|
it('setUserVideo calls client method with userId and videoElement', async () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
const videoElement = document.createElement('video');
|
|
|
|
await surface.setUserVideo('user-1', videoElement);
|
|
expect(gameWebrtc.client.setUserVideo).toHaveBeenCalledWith('user-1', videoElement);
|
|
});
|
|
|
|
it('setUserVideo validates userId is string', async () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
const videoElement = document.createElement('video');
|
|
|
|
await surface.setUserVideo(null, videoElement);
|
|
expect(consoleWarnSpy).toHaveBeenCalled();
|
|
expect(gameWebrtc.client.setUserVideo).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('setUserVideo validates videoElement is HTMLVideoElement', async () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
await surface.setUserVideo('user-1', {});
|
|
expect(consoleWarnSpy).toHaveBeenCalled();
|
|
expect(gameWebrtc.client.setUserVideo).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('input validation for userId-taking methods', () => {
|
|
it('getLevelsStreamForUser warns on empty userId', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
const result = surface.getLevelsStreamForUser('');
|
|
expect(result).toBeNull();
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] getLevelsStreamForUser: invalid userId:',
|
|
''
|
|
);
|
|
});
|
|
|
|
it('disableTrack warns on invalid userId', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.disableTrack(null);
|
|
expect(consoleWarnSpy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('enableTrack warns on invalid userId', () => {
|
|
const gameWebrtc = makeFullGameWebrtc();
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.enableTrack(123);
|
|
expect(consoleWarnSpy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('disableTrack', () => {
|
|
it('sets track.enabled = false on all video tracks for the user', () => {
|
|
const stream = makeStream(true);
|
|
const gameWebrtc = makeGameWebrtc(stream);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.disableTrack('user-123');
|
|
|
|
expect(gameWebrtc.client.getMediaStreamForUser).toHaveBeenCalledWith('user-123');
|
|
expect(stream._track.enabled).toBe(false);
|
|
});
|
|
|
|
it('logs [ScryingPool] warning when no video tracks found (stream has none)', () => {
|
|
const emptyStream = { getVideoTracks: vi.fn().mockReturnValue([]) };
|
|
const gameWebrtc = makeGameWebrtc(emptyStream);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.disableTrack('user-456');
|
|
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] disableTrack: no video tracks found for',
|
|
'user-456',
|
|
);
|
|
});
|
|
|
|
it('logs [ScryingPool] warning when getMediaStreamForUser returns null', () => {
|
|
const gameWebrtc = makeGameWebrtc(null);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.disableTrack('user-789');
|
|
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] disableTrack: no video tracks found for',
|
|
'user-789',
|
|
);
|
|
});
|
|
|
|
it('catches errors and logs [ScryingPool] error without throwing', () => {
|
|
const gameWebrtc = {
|
|
client: {
|
|
getMediaStreamForUser: vi.fn().mockImplementation(() => {
|
|
throw new Error('AV backend unavailable');
|
|
}),
|
|
},
|
|
};
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
expect(() => surface.disableTrack('user-err')).not.toThrow();
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] disableTrack failed:',
|
|
expect.any(Error),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('enableTrack', () => {
|
|
it('sets track.enabled = true on all video tracks for the user', () => {
|
|
const stream = makeStream(false);
|
|
const gameWebrtc = makeGameWebrtc(stream);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.enableTrack('user-123');
|
|
|
|
expect(gameWebrtc.client.getMediaStreamForUser).toHaveBeenCalledWith('user-123');
|
|
expect(stream._track.enabled).toBe(true);
|
|
});
|
|
|
|
it('logs [ScryingPool] warning when no video tracks found', () => {
|
|
const emptyStream = { getVideoTracks: vi.fn().mockReturnValue([]) };
|
|
const gameWebrtc = makeGameWebrtc(emptyStream);
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
surface.enableTrack('user-456');
|
|
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] enableTrack: no video tracks found for',
|
|
'user-456',
|
|
);
|
|
});
|
|
|
|
it('catches errors and logs [ScryingPool] error without throwing', () => {
|
|
const gameWebrtc = {
|
|
client: {
|
|
getMediaStreamForUser: vi.fn().mockImplementation(() => {
|
|
throw new Error('AV backend unavailable');
|
|
}),
|
|
},
|
|
};
|
|
const surface = FoundryAdapter.buildWebRTCSurface(gameWebrtc);
|
|
|
|
expect(() => surface.enableTrack('user-err')).not.toThrow();
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
'[ScryingPool] enableTrack failed:',
|
|
expect.any(Error),
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
// ─── Constructor + interface shape parity ─────────────────────────────────────
|
|
|
|
describe('FoundryAdapter constructor', () => {
|
|
beforeEach(() => {
|
|
vi.stubGlobal('Hooks', HOOKS_STUB);
|
|
vi.stubGlobal('ui', UI_STUB);
|
|
vi.clearAllMocks();
|
|
});
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
it('is side-effect-free — instantiates without accessing game.* (no game arg)', () => {
|
|
expect(() => new FoundryAdapter()).not.toThrow();
|
|
});
|
|
|
|
it('accepts game as constructor arg and stores it', () => {
|
|
const adapter = new FoundryAdapter(GAME_STUB);
|
|
expect(adapter._game).toBe(GAME_STUB);
|
|
});
|
|
|
|
it('has webrtc = null by default (css-fallback path)', () => {
|
|
const adapter = new FoundryAdapter(GAME_STUB);
|
|
expect(adapter.webrtc).toBeNull();
|
|
});
|
|
|
|
it('exposes SETTINGS_NS and SETTING_WEBRTC_MODE static constants', () => {
|
|
expect(typeof FoundryAdapter.SETTINGS_NS).toBe('string');
|
|
expect(FoundryAdapter.SETTINGS_NS).toBe('scrying-pool');
|
|
expect(typeof FoundryAdapter.SETTING_WEBRTC_MODE).toBe('string');
|
|
expect(FoundryAdapter.SETTING_WEBRTC_MODE).toBe('webrtcMode');
|
|
});
|
|
|
|
it('exposes all 6 surfaces: settings, socket, users, scenes, notifications, hooks', () => {
|
|
const adapter = new FoundryAdapter(GAME_STUB);
|
|
expect(typeof adapter.settings).toBe('object');
|
|
expect(typeof adapter.socket).toBe('object');
|
|
expect(typeof adapter.users).toBe('object');
|
|
expect(typeof adapter.scenes).toBe('object');
|
|
expect(typeof adapter.notifications).toBe('object');
|
|
expect(typeof adapter.hooks).toBe('object');
|
|
});
|
|
});
|
|
|
|
// ─── Surface delegation ────────────────────────────────────────────────────────
|
|
|
|
describe('FoundryAdapter surface delegation', () => {
|
|
let adapter;
|
|
|
|
beforeEach(() => {
|
|
vi.stubGlobal('Hooks', HOOKS_STUB);
|
|
vi.stubGlobal('ui', UI_STUB);
|
|
vi.clearAllMocks();
|
|
adapter = new FoundryAdapter(GAME_STUB);
|
|
});
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
describe('settings surface', () => {
|
|
it('settings.register delegates to game.settings.register with namespace', () => {
|
|
adapter.settings.register('visibilityMatrix', { default: {} });
|
|
expect(SETTINGS_STUB.register).toHaveBeenCalledWith('scrying-pool', 'visibilityMatrix', { default: {} });
|
|
});
|
|
|
|
it('settings.get delegates to game.settings.get with namespace', () => {
|
|
SETTINGS_STUB.get.mockReturnValue({ userId1: 'active' });
|
|
const result = adapter.settings.get('visibilityMatrix');
|
|
expect(SETTINGS_STUB.get).toHaveBeenCalledWith('scrying-pool', 'visibilityMatrix');
|
|
expect(result).toEqual({ userId1: 'active' });
|
|
});
|
|
|
|
it('settings.set delegates to game.settings.set with namespace', async () => {
|
|
SETTINGS_STUB.set.mockResolvedValue({ userId1: 'hidden' });
|
|
await adapter.settings.set('visibilityMatrix', { userId1: 'hidden' });
|
|
expect(SETTINGS_STUB.set).toHaveBeenCalledWith('scrying-pool', 'visibilityMatrix', { userId1: 'hidden' });
|
|
});
|
|
});
|
|
|
|
describe('socket surface', () => {
|
|
it('socket.emit delegates to game.socket.emit', () => {
|
|
adapter.socket.emit('scrying-pool.visibility.set', { opId: 'op-1' });
|
|
expect(SOCKET_STUB.emit).toHaveBeenCalledWith('scrying-pool.visibility.set', { opId: 'op-1' });
|
|
});
|
|
|
|
it('socket.on delegates to game.socket.on', () => {
|
|
const handler = vi.fn();
|
|
adapter.socket.on('scrying-pool.visibility.set', handler);
|
|
expect(SOCKET_STUB.on).toHaveBeenCalledWith('scrying-pool.visibility.set', handler);
|
|
});
|
|
|
|
it('socket.off delegates to game.socket.off', () => {
|
|
const handler = vi.fn();
|
|
adapter.socket.off('scrying-pool.visibility.set', handler);
|
|
expect(SOCKET_STUB.off).toHaveBeenCalledWith('scrying-pool.visibility.set', handler);
|
|
});
|
|
});
|
|
|
|
describe('users surface', () => {
|
|
it('users.get returns user by id', () => {
|
|
const result = adapter.users.get(GM_USER.id);
|
|
expect(USERS_STUB.get).toHaveBeenCalledWith(GM_USER.id);
|
|
expect(result).toBe(GM_USER);
|
|
});
|
|
|
|
it('users.get returns null for unknown id', () => {
|
|
expect(adapter.users.get('unknown-id')).toBeNull();
|
|
});
|
|
|
|
it('users.all returns array from game.users iteration', () => {
|
|
const result = adapter.users.all();
|
|
expect(Array.isArray(result)).toBe(true);
|
|
expect(result).toContain(GM_USER);
|
|
expect(result).toContain(PLAYER_USER);
|
|
});
|
|
|
|
it('users.isGM(id) checks a specific user', () => {
|
|
expect(adapter.users.isGM(GM_USER.id)).toBe(true);
|
|
expect(adapter.users.isGM(PLAYER_USER.id)).toBe(false);
|
|
});
|
|
|
|
it('users.isGM() with no arg checks current user', () => {
|
|
expect(adapter.users.isGM()).toBe(true); // USER_STUB is GM
|
|
});
|
|
|
|
it('users.current() returns game.user', () => {
|
|
expect(adapter.users.current()).toEqual({ id: GM_USER.id, name: GM_USER.name, isGM: true });
|
|
});
|
|
|
|
describe('user flag methods', () => {
|
|
it('users.getFlag returns flag value for valid user, scope, and key', () => {
|
|
// First set a flag on the GM user
|
|
GM_USER.setFlag('scrying-pool', 'testFlag', 'testValue');
|
|
const result = adapter.users.getFlag(GM_USER.id, 'scrying-pool', 'testFlag');
|
|
expect(result).toBe('testValue');
|
|
expect(USERS_STUB.get).toHaveBeenCalledWith(GM_USER.id);
|
|
});
|
|
|
|
it('users.getFlag returns null when flag does not exist', () => {
|
|
const result = adapter.users.getFlag(GM_USER.id, 'scrying-pool', 'nonExistentFlag');
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('users.getFlag returns null when user does not exist', () => {
|
|
const result = adapter.users.getFlag('unknown-user-id', 'scrying-pool', 'testFlag');
|
|
expect(result).toBeNull();
|
|
expect(USERS_STUB.get).toHaveBeenCalledWith('unknown-user-id');
|
|
});
|
|
|
|
it('users.setFlag sets flag value for valid user', async () => {
|
|
const promise = adapter.users.setFlag(PLAYER_USER.id, 'scrying-pool', 'reactionCamEnabled', true);
|
|
expect(promise).not.toBeNull();
|
|
await promise;
|
|
expect(USERS_STUB.get).toHaveBeenCalledWith(PLAYER_USER.id);
|
|
// Verify the flag was set
|
|
expect(PLAYER_USER.getFlag('scrying-pool', 'reactionCamEnabled')).toBe(true);
|
|
});
|
|
|
|
it('users.setFlag returns null when user does not exist', () => {
|
|
const promise = adapter.users.setFlag('unknown-user-id', 'scrying-pool', 'testFlag', true);
|
|
expect(promise).toBeNull();
|
|
expect(USERS_STUB.get).toHaveBeenCalledWith('unknown-user-id');
|
|
});
|
|
|
|
it('users.getFlagModule returns module-scoped flag', () => {
|
|
GM_USER.setFlag('scrying-pool', 'reactionCamEnabled', false);
|
|
const result = adapter.users.getFlagModule(GM_USER.id, 'reactionCamEnabled');
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('users.getFlagModule returns null when flag does not exist', () => {
|
|
const result = adapter.users.getFlagModule(GM_USER.id, 'nonExistentFlag');
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('users.setFlagModule sets module-scoped flag', async () => {
|
|
const promise = adapter.users.setFlagModule(PLAYER_USER.id, 'reactionCamEnabled', true);
|
|
expect(promise).not.toBeNull();
|
|
await promise;
|
|
expect(PLAYER_USER.getFlag('scrying-pool', 'reactionCamEnabled')).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('scenes surface', () => {
|
|
it('scenes.current() returns game.scenes.active', () => {
|
|
expect(adapter.scenes.current()).toBe(ACTIVE_SCENE);
|
|
});
|
|
|
|
it('scenes.get(id) delegates to game.scenes.get', () => {
|
|
const result = adapter.scenes.get(ACTIVE_SCENE.id);
|
|
expect(SCENES_STUB.get).toHaveBeenCalledWith(ACTIVE_SCENE.id);
|
|
expect(result).toBe(ACTIVE_SCENE);
|
|
});
|
|
|
|
it('scenes.get returns null for unknown id', () => {
|
|
expect(adapter.scenes.get('no-such-scene')).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('notifications surface', () => {
|
|
it('notifications.info delegates to ui.notifications.info', () => {
|
|
adapter.notifications.info('Test info');
|
|
expect(UI_STUB.notifications.info).toHaveBeenCalledWith('Test info');
|
|
});
|
|
|
|
it('notifications.warn delegates to ui.notifications.warn', () => {
|
|
adapter.notifications.warn('Test warn');
|
|
expect(UI_STUB.notifications.warn).toHaveBeenCalledWith('Test warn');
|
|
});
|
|
|
|
it('notifications.error delegates to ui.notifications.error', () => {
|
|
adapter.notifications.error('Test error');
|
|
expect(UI_STUB.notifications.error).toHaveBeenCalledWith('Test error');
|
|
});
|
|
});
|
|
|
|
describe('hooks surface', () => {
|
|
it('hooks.on delegates to Hooks.on', () => {
|
|
const handler = vi.fn();
|
|
adapter.hooks.on('ready', handler);
|
|
expect(HOOKS_STUB.on).toHaveBeenCalledWith('ready', handler);
|
|
});
|
|
|
|
it('hooks.once delegates to Hooks.once', () => {
|
|
const handler = vi.fn();
|
|
adapter.hooks.once('ready', handler);
|
|
expect(HOOKS_STUB.once).toHaveBeenCalledWith('ready', handler);
|
|
});
|
|
|
|
it('hooks.off delegates to Hooks.off', () => {
|
|
const handler = vi.fn();
|
|
adapter.hooks.off('ready', handler);
|
|
expect(HOOKS_STUB.off).toHaveBeenCalledWith('ready', handler);
|
|
});
|
|
});
|
|
});
|