orbital-command 0.2.0 → 1.0.0

package/dist/server/server/services/scope-service.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { ScopeService } from './scope-service.js';
+import { ScopeCache } from './scope-cache.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { CONFIG_WITH_HOOKS } from '../../shared/__fixtures__/workflow-configs.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+describe('ScopeService', () => {
+    let tmpDir;
+    let cache;
+    let emitter;
+    let engine;
+    let service;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'scope-svc-test-'));
+        cache = new ScopeCache();
+        emitter = createMockEmitter();
+        engine = new WorkflowEngine(CONFIG_WITH_HOOKS);
+        service = new ScopeService(cache, emitter, tmpDir, engine);
+        // Create status directories
+        for (const status of ['icebox', 'backlog', 'active', 'review', 'shipped']) {
+            fs.mkdirSync(path.join(tmpDir, status), { recursive: true });
+        }
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeScopeFile(status, filename, frontmatter, body = '') {
+        const filePath = path.join(tmpDir, status, filename);
+        const yamlLines = Object.entries(frontmatter).map(([k, v]) => {
+            if (Array.isArray(v))
+                return `${k}: [${v.join(', ')}]`;
+            return `${k}: ${v}`;
+        }).join('\n');
+        fs.writeFileSync(filePath, `---\n${yamlLines}\n---\n${body}\n`);
+        return filePath;
+    }
+    // ─── syncFromFilesystem() ─────────────────────────────────
+    describe('syncFromFilesystem()', () => {
+        it('loads all .md files into cache', () => {
+            writeScopeFile('backlog', '001-first.md', { title: 'First', status: 'backlog' });
+            writeScopeFile('active', '002-second.md', { title: 'Second', status: 'active' });
+            const count = service.syncFromFilesystem();
+            expect(count).toBe(2);
+            expect(cache.size).toBe(2);
+        });
+        it('returns 0 for empty directories', () => {
+            expect(service.syncFromFilesystem()).toBe(0);
+        });
+    });
+    // ─── getAll() / getById() ─────────────────────────────────
+    describe('getAll() / getById()', () => {
+        it('delegates to cache', () => {
+            writeScopeFile('backlog', '001-test.md', { title: 'Test', status: 'backlog' });
+            service.syncFromFilesystem();
+            expect(service.getAll()).toHaveLength(1);
+            expect(service.getById(1)?.title).toBe('Test');
+            expect(service.getById(999)).toBeUndefined();
+        });
+    });
+    // ─── updateStatus() ──────────────────────────────────────
+    describe('updateStatus()', () => {
+        beforeEach(() => {
+            writeScopeFile('backlog', '001-test.md', { title: 'Test', status: 'backlog' });
+            service.syncFromFilesystem();
+        });
+        it('validates transition via engine', () => {
+            // backlog → shipped is not a valid edge in CONFIG_WITH_HOOKS
+            const result = service.updateStatus(1, 'shipped', 'patch');
+            expect(result.ok).toBe(false);
+        });
+        it('bulk-sync bypasses validation', () => {
+            const result = service.updateStatus(1, 'shipped', 'bulk-sync');
+            expect(result.ok).toBe(true);
+        });
+        it('returns NOT_FOUND for unknown scope', () => {
+            const result = service.updateStatus(999, 'active', 'dispatch');
+            expect(result.ok).toBe(false);
+        });
+        it('fires onStatusChange callbacks on successful transition', () => {
+            const callback = vi.fn();
+            service.onStatusChange(callback);
+            // Use bulk-sync to bypass edge validation — focuses on the callback mechanism
+            const result = service.updateStatus(1, 'active', 'bulk-sync');
+            if (result.ok) {
+                expect(callback).toHaveBeenCalledWith(1, 'active');
+            }
+        });
+    });
+    // ─── createIdeaFile() ─────────────────────────────────────
+    describe('createIdeaFile()', () => {
+        it('creates file in icebox directory', () => {
+            const result = service.createIdeaFile('My New Idea', 'A description of the idea');
+            expect(result.slug).toBeDefined();
+            expect(result.title).toBe('My New Idea');
+            // Verify file exists
+            const files = fs.readdirSync(path.join(tmpDir, 'icebox'));
+            expect(files.length).toBe(1);
+            expect(files[0]).toMatch(/\.md$/);
+        });
+        it('slugifies the title', () => {
+            const result = service.createIdeaFile('Some Feature Idea!', '');
+            expect(result.slug).toMatch(/^[a-z0-9-]+$/);
+        });
+    });
+    // ─── deleteIdeaFile() ─────────────────────────────────────
+    describe('deleteIdeaFile()', () => {
+        it('removes the idea file', () => {
+            const { slug } = service.createIdeaFile('To Delete', '');
+            const result = service.deleteIdeaFile(slug);
+            expect(result).toBe(true);
+            const files = fs.readdirSync(path.join(tmpDir, 'icebox'));
+            expect(files).toHaveLength(0);
+        });
+        it('returns false for non-existent slug', () => {
+            expect(service.deleteIdeaFile('nonexistent-slug')).toBe(false);
+        });
+    });
+    // ─── reconcileDirectories() ───────────────────────────────
+    describe('reconcileDirectories()', () => {
+        it('moves files to correct directory based on frontmatter', () => {
+            // Put a file in backlog but with status: active in frontmatter
+            writeScopeFile('backlog', '001-misplaced.md', { title: 'Misplaced', status: 'active' });
+            service.syncFromFilesystem();
+            const moved = service.reconcileDirectories();
+            expect(moved).toBeGreaterThanOrEqual(0);
+        });
+    });
+    // ─── isSuppressed() ──────────────────────────────────────
+    describe('isSuppressed()', () => {
+        it('returns false by default', () => {
+            expect(service.isSuppressed('/some/path.md')).toBe(false);
+        });
+    });
+});

package/dist/server/server/services/sprint-orchestrator.js

@@ -1,6 +1,6 @@
-import { launchInCategorizedTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
 import { resolveDispatchEvent, linkPidToDispatch } from '../utils/dispatch-utils.js';
-import { getConfig } from '../config.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('sprint');
 const LAUNCH_STAGGER_MS = 2000;
@@ -14,12 +14,16 @@ export class SprintOrchestrator {
     sprintService;
     scopeService;
     engine;
-    constructor(db, io, sprintService, scopeService, engine) {
+    projectRoot;
+    config;
+    constructor(db, io, sprintService, scopeService, engine, projectRoot, config) {
         this.db = db;
         this.io = io;
         this.sprintService = sprintService;
         this.scopeService = scopeService;
         this.engine = engine;
+        this.projectRoot = projectRoot;
+        this.config = config;
     }
     /** Build execution layers using Kahn's topological sort */
     buildExecutionLayers(sprintScopeIds) {
@@ -97,13 +101,14 @@ export class SprintOrchestrator {
         const match = this.sprintService.findActiveSprintForScope(scopeId);
         if (!match)
             return;
-        log.debug('Scope reached dev', { scopeId, sprintId: match.sprint_id });
+        // Batches are managed by BatchOrchestrator — don't dispatch individual scopes
         const sprintId = match.sprint_id;
-        this.sprintService.updateScopeStatus(sprintId, scopeId, 'completed');
-        // Ensure sprint is in 'in_progress' state
         const sprint = this.sprintService.getById(sprintId);
-        if (!sprint)
+        if (!sprint || sprint.group_type === 'batch')
             return;
+        log.debug('Scope reached dev', { scopeId, sprintId });
+        this.sprintService.updateScopeStatus(sprintId, scopeId, 'completed');
+        // Ensure sprint is in 'in_progress' state
         if (sprint.status === 'dispatched') {
             this.sprintService.updateStatus(sprintId, 'in_progress');
         }
@@ -168,7 +173,7 @@ export class SprintOrchestrator {
         const sprint = this.sprintService.getById(sprintId);
         if (!sprint)
             return null;
-        const layers = sprint.layers ?? [];
+        const layers = sprint.layers ?? this.buildExecutionLayers(sprint.scope_ids).layers;
         const sprintSet = new Set(sprint.scope_ids);
         const edges = [];
         for (const scopeId of sprint.scope_ids) {
@@ -191,9 +196,14 @@ export class SprintOrchestrator {
             // Capture current status before optimistic update (for rollback)
             const currentScope = this.scopeService.getById(scopeId);
             const previousStatus = currentScope?.status ?? 'implementing';
+            // Resolve command and target status from workflow engine
+            const sprint = this.sprintService.getById(sprintId);
+            const targetColumn = sprint?.target_column ?? 'backlog';
+            const edgeCommand = this.engine.getBatchCommand(targetColumn);
+            const targetStatus = this.engine.getBatchTargetStatus(targetColumn);
             // Record DISPATCH event
             const eventId = crypto.randomUUID();
-            const command = `/scope implement ${scopeId}`;
+            const command = edgeCommand ?? `/scope-implement ${scopeId}`;
             this.db.prepare(`INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
          VALUES (?, 'DISPATCH', ?, NULL, 'sprint-orchestrator', ?, ?)`).run(eventId, scopeId, JSON.stringify({ command, sprint_id: sprintId, resolved: null }), new Date().toISOString());
             this.io.emit('event:new', {
@@ -203,25 +213,29 @@ export class SprintOrchestrator {
                 timestamp: new Date().toISOString(),
             });
             // Update scope + sprint_scope status
-            this.scopeService.updateStatus(scopeId, 'implementing', 'dispatch');
+            if (targetStatus) {
+                this.scopeService.updateStatus(scopeId, targetStatus, 'dispatch');
+            }
             this.sprintService.updateScopeStatus(sprintId, scopeId, 'dispatched');
             // Build scope-aware session name and snapshot PIDs
             const scopeRow = this.scopeService.getById(scopeId);
             const sessionName = buildSessionName({ scopeId, title: scopeRow?.title, command });
-            const beforePids = snapshotSessionPids(getConfig().projectRoot);
-            // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+            const beforePids = snapshotSessionPids(this.projectRoot);
+            // Launch in iTerm — interactive TUI mode for full visibility
             const escaped = escapeForAnsiC(command);
-            const fullCmd = `cd '${getConfig().projectRoot}' && claude --dangerously-skip-permissions $'${escaped}'`;
+            const flagsStr = buildClaudeFlags(this.config.claude.dispatchFlags);
+            const envPrefix = buildEnvVarPrefix(this.config.dispatch.envVars);
+            const fullCmd = `cd '${shellQuote(this.projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${flagsStr} $'${escaped}'`;
             try {
                 await launchInCategorizedTerminal(command, fullCmd, sessionName);
                 // Fire-and-forget: discover session PID, link to dispatch, and rename
-                discoverNewSession(getConfig().projectRoot, beforePids)
+                discoverNewSession(this.projectRoot, beforePids)
                     .then((session) => {
                     if (!session)
                         return;
                     linkPidToDispatch(this.db, eventId, session.pid);
                     if (sessionName)
-                        renameSession(getConfig().projectRoot, session.sessionId, sessionName);
+                        renameSession(this.projectRoot, session.sessionId, sessionName);
                 })
                     .catch(err => log.error('PID discovery failed', { error: err.message }));
             }

package/dist/server/server/services/sprint-service.js

@@ -47,7 +47,24 @@ export class SprintService {
         else {
             rows = this.db.prepare('SELECT * FROM sprints ORDER BY created_at DESC').all();
         }
-        return rows.map((row) => this.buildDetail(row));
+        if (rows.length === 0)
+            return [];
+        // Batch-fetch all sprint_scopes in one query to avoid N+1
+        const sprintIds = rows.map(r => r.id);
+        const placeholders = sprintIds.map(() => '?').join(',');
+        const allScopeRows = this.db.prepare(`SELECT sprint_id, scope_id, layer, dispatch_status FROM sprint_scopes
+       WHERE sprint_id IN (${placeholders}) ORDER BY layer ASC, scope_id ASC`).all(...sprintIds);
+        // Group by sprint_id
+        const scopesBySprintId = new Map();
+        for (const ss of allScopeRows) {
+            let arr = scopesBySprintId.get(ss.sprint_id);
+            if (!arr) {
+                arr = [];
+                scopesBySprintId.set(ss.sprint_id, arr);
+            }
+            arr.push(ss);
+        }
+        return rows.map((row) => this.buildDetailFromScopes(row, scopesBySprintId.get(row.id) ?? []));
     }
     /** Get full sprint detail by ID */
     getById(id) {
@@ -56,10 +73,10 @@ export class SprintService {
             return null;
         return this.buildDetail(row);
     }
-    /** Delete a sprint (only if assembling) */
+    /** Delete a sprint/batch (assembling, failed, or cancelled) */
     delete(id) {
         const row = this.db.prepare('SELECT status FROM sprints WHERE id = ?').get(id);
-        if (!row || row.status !== 'assembling')
+        if (!row || !['assembling', 'failed', 'cancelled', 'completed'].includes(row.status))
             return false;
         this.db.prepare('DELETE FROM sprint_scopes WHERE sprint_id = ?').run(id);
         this.db.prepare('DELETE FROM sprints WHERE id = ?').run(id);
@@ -231,6 +248,9 @@ export class SprintService {
     buildDetail(row) {
         const ssRows = this.db.prepare(`SELECT scope_id, layer, dispatch_status FROM sprint_scopes
        WHERE sprint_id = ? ORDER BY layer ASC, scope_id ASC`).all(row.id);
+        return this.buildDetailFromScopes(row, ssRows);
+    }
+    buildDetailFromScopes(row, ssRows) {
         const progress = { pending: 0, in_progress: 0, completed: 0, failed: 0, skipped: 0 };
         const scopes = [];
         for (const ss of ssRows) {

package/dist/server/server/services/sprint-service.test.js

@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SprintService } from './sprint-service.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+function makeScope(overrides) {
+    return {
+        title: `Scope ${overrides.id}`,
+        slug: undefined,
+        status: 'backlog',
+        priority: null,
+        effort_estimate: null,
+        category: null,
+        tags: [],
+        blocked_by: [],
+        blocks: [],
+        file_path: `/scopes/backlog/${String(overrides.id).padStart(3, '0')}-test.md`,
+        created_at: null,
+        updated_at: null,
+        raw_content: '',
+        sessions: {},
+        is_ghost: false,
+        favourite: false,
+        ...overrides,
+    };
+}
+function createMockScopeService(scopes) {
+    return { getById: (id) => scopes.find(s => s.id === id) };
+}
+describe('SprintService', () => {
+    let db;
+    let cleanup;
+    let emitter;
+    let service;
+    const testScopes = [
+        makeScope({ id: 1, title: 'Scope 1', status: 'backlog' }),
+        makeScope({ id: 2, title: 'Scope 2', status: 'backlog' }),
+        makeScope({ id: 3, title: 'Scope 3', status: 'backlog', blocked_by: [99] }),
+        makeScope({ id: 4, title: 'Scope 4', status: 'implementing' }),
+    ];
+    beforeEach(() => {
+        ({ db, cleanup } = createTestDb());
+        // Add migration columns that SCHEMA_DDL may not include
+        try {
+            db.prepare("ALTER TABLE sprints ADD COLUMN target_column TEXT DEFAULT 'backlog'").run();
+        }
+        catch { /* already exists */ }
+        try {
+            db.prepare("ALTER TABLE sprints ADD COLUMN group_type TEXT DEFAULT 'sprint'").run();
+        }
+        catch { /* already exists */ }
+        try {
+            db.prepare("ALTER TABLE sprints ADD COLUMN dispatch_result TEXT DEFAULT '{}'").run();
+        }
+        catch { /* already exists */ }
+        emitter = createMockEmitter();
+        const mockScopeService = createMockScopeService(testScopes);
+        service = new SprintService(db, emitter, mockScopeService);
+    });
+    afterEach(() => {
+        cleanup?.();
+    });
+    // ─── create() ─────────────────────────────────────────────
+    describe('create()', () => {
+        it('creates sprint with default values', () => {
+            const sprint = service.create('Test Sprint');
+            expect(sprint.name).toBe('Test Sprint');
+            expect(sprint.status).toBe('assembling');
+            expect(sprint.concurrency_cap).toBe(5);
+            expect(sprint.group_type).toBe('sprint');
+            expect(sprint.target_column).toBe('backlog');
+        });
+        it('creates batch with custom options', () => {
+            const sprint = service.create('Test Batch', { group_type: 'batch', target_column: 'review' });
+            expect(sprint.group_type).toBe('batch');
+            expect(sprint.target_column).toBe('review');
+        });
+        it('emits sprint:created', () => {
+            service.create('Test Sprint');
+            expect(emitter.emit).toHaveBeenCalledWith('sprint:created', expect.objectContaining({ name: 'Test Sprint' }));
+        });
+    });
+    // ─── getAll() / getById() ─────────────────────────────────
+    describe('getAll() / getById()', () => {
+        it('returns all sprints', () => {
+            service.create('Sprint 1');
+            service.create('Sprint 2');
+            expect(service.getAll()).toHaveLength(2);
+        });
+        it('filters by status', () => {
+            service.create('Sprint 1');
+            const all = service.getAll('assembling');
+            expect(all).toHaveLength(1);
+            expect(service.getAll('dispatched')).toHaveLength(0);
+        });
+        it('returns null for unknown ID', () => {
+            expect(service.getById(999)).toBeNull();
+        });
+    });
+    // ─── rename() / delete() ──────────────────────────────────
+    describe('rename()', () => {
+        it('renames an assembling sprint', () => {
+            const sprint = service.create('Original');
+            const result = service.rename(sprint.id, 'Renamed');
+            expect(result).toBe(true);
+            expect(service.getById(sprint.id).name).toBe('Renamed');
+        });
+        it('returns false for non-assembling sprint', () => {
+            const sprint = service.create('Sprint');
+            service.updateStatus(sprint.id, 'dispatched');
+            expect(service.rename(sprint.id, 'New Name')).toBe(false);
+        });
+    });
+    describe('delete()', () => {
+        it('deletes sprint and emits event', () => {
+            const sprint = service.create('To Delete');
+            const result = service.delete(sprint.id);
+            expect(result).toBe(true);
+            expect(service.getById(sprint.id)).toBeNull();
+            expect(emitter.emit).toHaveBeenCalledWith('sprint:deleted', expect.objectContaining({ id: sprint.id }));
+        });
+    });
+    // ─── addScopes() ──────────────────────────────────────────
+    describe('addScopes()', () => {
+        it('adds scopes to assembling sprint', () => {
+            const sprint = service.create('Sprint');
+            const result = service.addScopes(sprint.id, [1, 2]);
+            expect(result).not.toBeNull();
+            expect(result.added).toEqual([1, 2]);
+        });
+        it('returns null for non-existent sprint', () => {
+            expect(service.addScopes(999, [1])).toBeNull();
+        });
+        it('reports unmet dependencies', () => {
+            const sprint = service.create('Sprint');
+            const result = service.addScopes(sprint.id, [3]); // scope 3 is blocked_by [99]
+            expect(result).not.toBeNull();
+            expect(result.unmet_dependencies.length).toBeGreaterThanOrEqual(0);
+        });
+        it('skips scopes that are already in the sprint', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1]);
+            const result = service.addScopes(sprint.id, [1, 2]);
+            expect(result).not.toBeNull();
+            expect(result.added).toEqual([2]);
+        });
+    });
+    // ─── removeScopes() ──────────────────────────────────────
+    describe('removeScopes()', () => {
+        it('removes scopes from assembling sprint', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1, 2]);
+            const result = service.removeScopes(sprint.id, [1]);
+            expect(result).toBe(true);
+            const updated = service.getById(sprint.id);
+            expect(updated.scope_ids).not.toContain(1);
+        });
+    });
+    // ─── updateStatus() ──────────────────────────────────────
+    describe('updateStatus()', () => {
+        it('transitions to dispatched and sets dispatched_at', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1]);
+            service.updateStatus(sprint.id, 'dispatched');
+            const updated = service.getById(sprint.id);
+            expect(updated.status).toBe('dispatched');
+            expect(updated.dispatched_at).not.toBeNull();
+        });
+        it('transitions to completed and sets completed_at', () => {
+            const sprint = service.create('Sprint');
+            service.updateStatus(sprint.id, 'completed');
+            const updated = service.getById(sprint.id);
+            expect(updated.status).toBe('completed');
+            expect(updated.completed_at).not.toBeNull();
+        });
+        it('emits sprint:updated on status change', () => {
+            const sprint = service.create('Sprint');
+            emitter.emit.mockClear();
+            service.updateStatus(sprint.id, 'dispatched');
+            expect(emitter.emit).toHaveBeenCalledWith('sprint:updated', expect.objectContaining({ status: 'dispatched' }));
+        });
+    });
+    // ─── updateScopeStatus() ─────────────────────────────────
+    describe('updateScopeStatus()', () => {
+        it('updates dispatch_status for a scope in sprint', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1]);
+            service.updateScopeStatus(sprint.id, 1, 'in_progress');
+            const updated = service.getById(sprint.id);
+            const scope = updated.scopes.find(s => s.scope_id === 1);
+            expect(scope?.dispatch_status).toBe('in_progress');
+        });
+        it('records error for failed scopes', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1]);
+            service.updateScopeStatus(sprint.id, 1, 'failed', 'Timeout');
+            const rows = db.prepare('SELECT error FROM sprint_scopes WHERE scope_id = 1').all();
+            expect(rows[0].error).toBe('Timeout');
+        });
+    });
+    // ─── setLayers() ──────────────────────────────────────────
+    describe('setLayers()', () => {
+        it('stores layer assignment', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1, 2]);
+            service.setLayers(sprint.id, [[1], [2]]);
+            const updated = service.getById(sprint.id);
+            expect(updated.layers).toEqual([[1], [2]]);
+        });
+    });
+    // ─── findActiveSprintForScope() ───────────────────────────
+    describe('findActiveSprintForScope()', () => {
+        it('returns active sprint containing the scope', () => {
+            const sprint = service.create('Sprint');
+            service.addScopes(sprint.id, [1]);
+            service.updateStatus(sprint.id, 'dispatched');
+            const active = service.findActiveSprintForScope(1);
+            expect(active).not.toBeNull();
+            expect(active.sprint_id).toBe(sprint.id);
+        });
+        it('returns null/undefined when scope is not in any active sprint', () => {
+            expect(service.findActiveSprintForScope(99)).toBeFalsy();
+        });
+    });
+    // ─── getActiveGroupForScope() ─────────────────────────────
+    describe('getActiveGroupForScope()', () => {
+        it('returns group info for scope in active sprint', () => {
+            const sprint = service.create('Batch', { group_type: 'batch' });
+            service.addScopes(sprint.id, [1]);
+            service.updateStatus(sprint.id, 'dispatched');
+            const group = service.getActiveGroupForScope(1);
+            expect(group).not.toBeNull();
+            expect(group.group_type).toBe('batch');
+        });
+        it('returns null/undefined when scope is not in any active group', () => {
+            expect(service.getActiveGroupForScope(99)).toBeFalsy();
+        });
+    });
+});