orbital-command 0.1.4 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orbital-command",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "Orbital Command — mission control dashboard for Claude Code projects",
   "type": "module",
   "license": "MIT",
@@ -32,21 +32,16 @@
     "dist/",
     "server/",
     "shared/",
-    "src/",
     "templates/",
     "schemas/",
     "scripts/",
-    "index.html",
-    "vite.config.ts",
-    "tailwind.config.js",
-    "postcss.config.js",
-    "tsconfig.json",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "dev": "orbital dev",
     "dev:local": "trap 'lsof -ti:4444,4445 | xargs kill 2>/dev/null' EXIT; concurrently -n server,client -c blue,green \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:launch": "trap 'lsof -ti:4444,4445 | xargs kill 2>/dev/null' EXIT; concurrently -n central,client -c magenta,green \"ORBITAL_LAUNCH_MODE=central ORBITAL_SERVER_PORT=4444 tsx watch server/launch.ts\" \"npm run dev:client\"",
     "dev:server": "tsx watch server/index.ts",
     "dev:client": "vite",
     "build": "./node_modules/.bin/vite build",
@@ -54,9 +49,15 @@
     "typecheck": "./node_modules/.bin/tsc --noEmit && ./node_modules/.bin/tsc --noEmit -p tsconfig.server.json",
     "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "npm run typecheck && npm run build && npm run build:server",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:unit": "vitest run --project unit",
+    "test:integration": "vitest run --project integration",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
+    "@clack/prompts": "^1.2.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
@@ -69,7 +70,9 @@
     "@radix-ui/react-slot": "^1.1.1",
     "@radix-ui/react-tabs": "^1.1.2",
     "@radix-ui/react-tooltip": "^1.1.6",
+    "@vitejs/plugin-react": "^4.7.0",
     "@xyflow/react": "^12.10.1",
+    "autoprefixer": "^10.4.27",
     "better-sqlite3": "^12.0.0",
     "chokidar": "^4.0.3",
     "class-variance-authority": "^0.7.1",
@@ -79,6 +82,8 @@
     "framer-motion": "^11.15.0",
     "gray-matter": "^4.0.3",
     "lucide-react": "^0.577.0",
+    "picocolors": "^1.1.1",
+    "postcss": "^8.5.8",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^10.1.0",
@@ -88,21 +93,21 @@
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
     "tailwind-merge": "^2.6.0",
-    "tsx": "^4.19.2",
-    "vite": "^6.0.7",
-    "@vitejs/plugin-react": "^4.7.0",
-    "autoprefixer": "^10.4.27",
-    "postcss": "^8.5.8",
     "tailwindcss": "^3.4.19",
-    "tailwindcss-animate": "^1.0.7"
+    "tailwindcss-animate": "^1.0.7",
+    "tsx": "^4.19.2",
+    "vite": "^6.0.7"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",
     "@types/express": "^5.0.0",
     "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",
+    "@types/supertest": "^7.2.0",
     "concurrently": "^9.2.1",
-    "typescript": "^5.7.3"
+    "supertest": "^7.2.2",
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.3"
   },
   "engines": {
     "node": ">=18.0.0"

package/schemas/orbital.config.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft-07/schema",
-  "$id": "https://orbital-command.dev/schemas/orbital.config.schema.json",
+  "$id": "https://raw.githubusercontent.com/SakaraLabs/orbital-command/main/schemas/orbital.config.schema.json",
   "title": "Orbital Command Configuration",
   "description": "Configuration file for Orbital Command — mission control for Claude Code projects",
   "type": "object",
@@ -77,6 +77,21 @@
         "production": { "type": "string", "format": "uri" }
       },
       "additionalProperties": { "type": "string", "format": "uri" }
+    },
+    "telemetry": {
+      "type": "object",
+      "description": "Session telemetry — uploads Claude session JSONL files to a remote endpoint. Can also be disabled via ORBITAL_TELEMETRY=false env var.",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true, "description": "Enable session telemetry upload" },
+        "url": { "type": "string", "description": "Base URL of the telemetry receiver (Cloudflare Worker)" },
+        "headers": {
+          "type": "object",
+          "additionalProperties": { "type": "string" },
+          "default": {},
+          "description": "Custom headers sent with upload requests (e.g. Authorization)"
+        }
+      },
+      "additionalProperties": false
     }
   },
   "additionalProperties": false

package/scripts/postinstall.js

@@ -1,20 +1,26 @@
 #!/usr/bin/env node
 
-// Safety net for esbuild's platform-specific binary.
-//
-// esbuild (a transitive dependency of Vite) ships as a stub that downloads
-// its native binary via postinstall. If that step was skipped or failed
-// silently, this script re-triggers the download.
+/**
+ * Postinstall script for orbital-command.
+ *
+ * 1. Ensures esbuild's platform-specific binary is present (safety net).
+ * 2. If this is an interactive terminal and Orbital hasn't been set up yet,
+ *    launches the Phase 1 setup wizard.
+ * 3. Otherwise, prints a banner with next steps.
+ */
 
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { execFileSync } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(__dirname, '..');
-const esbuildInstall = path.join(packageRoot, 'node_modules', 'esbuild', 'install.js');
+const orbitalHome = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
+
+// ─── 1. Esbuild safety net ─────────────────────────────────────
 
+const esbuildInstall = path.join(packageRoot, 'node_modules', 'esbuild', 'install.js');
 if (existsSync(esbuildInstall)) {
   try {
     execFileSync('node', [esbuildInstall], { stdio: 'pipe' });
@@ -22,3 +28,45 @@ if (existsSync(esbuildInstall)) {
     // Already installed or not applicable
   }
 }
+
+// ─── 2. Setup wizard or banner ──────────────────────────────────
+
+const isInteractive = process.stdout.isTTY && !process.env.CI;
+const alreadySetUp = existsSync(path.join(orbitalHome, 'config.json'));
+
+if (isInteractive && !alreadySetUp) {
+  // Launch the Phase 1 setup wizard
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    const version = pkg.version || '0.0.0';
+
+    let wizard;
+    try {
+      wizard = await import('../dist/server/server/wizard/index.js');
+    } catch {
+      try {
+        wizard = await import('../server/wizard/index.js');
+      } catch {
+        // Wizard module not available — fall through to banner
+        wizard = null;
+      }
+    }
+
+    if (wizard) {
+      await wizard.runSetupWizard(version);
+    } else {
+      printBanner();
+    }
+  } catch {
+    printBanner();
+  }
+} else if (!alreadySetUp) {
+  printBanner();
+}
+
+function printBanner() {
+  console.log('');
+  console.log('  Orbital Command installed.');
+  console.log('  Run `orbital` in your project directory to get started.');
+  console.log('');
+}

package/server/__tests__/data-routes.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createDataRoutes } from '../routes/data-routes.js';
+import { EventService } from '../services/event-service.js';
+import { GateService } from '../services/gate-service.js';
+import { DeployService } from '../services/deploy-service.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { createTestDb } from './helpers/db.js';
+import { createMockEmitter } from './helpers/mock-emitter.js';
+import { DEFAULT_CONFIG } from '../../shared/__fixtures__/workflow-configs.js';
+import type Database from 'better-sqlite3';
+
+describe('data-routes', () => {
+  let app: express.Express;
+  let db: Database.Database;
+  let cleanup: () => void;
+
+  beforeAll(() => {
+    ({ db, cleanup } = createTestDb());
+    const emitter = createMockEmitter();
+    const engine = new WorkflowEngine(DEFAULT_CONFIG);
+    const eventService = new EventService(db, emitter);
+    const gateService = new GateService(db, emitter);
+    const deployService = new DeployService(db, emitter);
+
+    const mockGitService = {
+      getPipelineDrift: vi.fn().mockReturnValue({ ahead: 0, behind: 0, files: [] }),
+      getStatusHash: vi.fn().mockReturnValue('abc123'),
+      getWorktrees: vi.fn().mockReturnValue([]),
+      getCurrentBranch: vi.fn().mockReturnValue('main'),
+      isDirty: vi.fn().mockReturnValue(false),
+    } as unknown;
+
+    const router = createDataRoutes({
+      db,
+      io: emitter,
+      eventService,
+      gateService,
+      deployService,
+      gitService: mockGitService as Parameters<typeof createDataRoutes>[0]['gitService'],
+      engine,
+      projectRoot: '/tmp/test-project',
+      inferScopeStatus: vi.fn(),
+    });
+
+    app = express();
+    app.use(express.json());
+    app.use('/api/orbital', router);
+  });
+
+  afterAll(() => {
+    cleanup?.();
+  });
+
+  // ─── Event Endpoints ──────────────────────────────────────
+
+  describe('POST /api/orbital/events', () => {
+    it('creates event with valid body (201)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/events')
+        .send({ type: 'TEST_EVENT', scope_id: 1, data: { foo: 'bar' } });
+
+      expect(res.status).toBe(201);
+      expect(res.body.type).toBe('TEST_EVENT');
+      expect(res.body.id).toBeDefined();
+    });
+
+    it('rejects missing type (400)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/events')
+        .send({ scope_id: 1 });
+
+      expect(res.status).toBe(400);
+      expect(res.body.error).toContain('type');
+    });
+
+    it('rejects invalid scope_id (400)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/events')
+        .send({ type: 'TEST', scope_id: -1 });
+
+      expect(res.status).toBe(400);
+      expect(res.body.error).toContain('scope_id');
+    });
+  });
+
+  describe('GET /api/orbital/events', () => {
+    it('returns events', async () => {
+      const res = await request(app).get('/api/orbital/events');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+    });
+  });
+
+  // ─── Gate Endpoints ───────────────────────────────────────
+
+  describe('POST /api/orbital/gates', () => {
+    it('records gate result (201)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/gates')
+        .send({ gate_name: 'type-check', status: 'pass', duration_ms: 1200 });
+
+      expect(res.status).toBe(201);
+    });
+  });
+
+  describe('GET /api/orbital/gates/stats', () => {
+    it('returns stats array', async () => {
+      const res = await request(app).get('/api/orbital/gates/stats');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+    });
+  });
+
+  // ─── Deployment Endpoints ─────────────────────────────────
+
+  describe('POST /api/orbital/deployments', () => {
+    it('records deployment (201)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/deployments')
+        .send({ environment: 'staging', status: 'deploying', commit_sha: 'abc' });
+
+      expect(res.status).toBe(201);
+      expect(res.body.id).toBeDefined();
+    });
+  });
+
+  describe('GET /api/orbital/deployments', () => {
+    it('returns recent deployments', async () => {
+      const res = await request(app).get('/api/orbital/deployments');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+    });
+  });
+
+  // ─── Violations Summary ───────────────────────────────────
+
+  describe('GET /api/orbital/events/violations/summary', () => {
+    it('returns summary structure', async () => {
+      const res = await request(app).get('/api/orbital/events/violations/summary');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveProperty('totalViolations');
+      expect(res.body).toHaveProperty('totalOverrides');
+      expect(res.body).toHaveProperty('byRule');
+      expect(res.body).toHaveProperty('byFile');
+    });
+  });
+});

package/server/__tests__/helpers/db.ts

@@ -0,0 +1,19 @@
+import Database from 'better-sqlite3';
+import { SCHEMA_DDL } from '../../schema.js';
+
+/**
+ * Create an in-memory SQLite database with the full Orbital schema.
+ * Returns the db handle and a cleanup function.
+ */
+export function createTestDb(): { db: Database.Database; cleanup: () => void } {
+  const db = new Database(':memory:');
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(SCHEMA_DDL);
+
+  return {
+    db,
+    cleanup: () => db.close(),
+  };
+}

package/server/__tests__/helpers/mock-emitter.ts

@@ -0,0 +1,10 @@
+import { vi } from 'vitest';
+import type { Emitter } from '../../project-emitter.js';
+
+/**
+ * Create a mock ProjectEmitter for testing services.
+ * Services only call emit(), so that's all we mock.
+ */
+export function createMockEmitter(): Emitter & { emit: ReturnType<typeof vi.fn> } {
+  return { emit: vi.fn().mockReturnValue(true) } as unknown as Emitter & { emit: ReturnType<typeof vi.fn> };
+}

package/server/__tests__/scope-routes.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createScopeRoutes } from '../routes/scope-routes.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { DEFAULT_CONFIG } from '../../shared/__fixtures__/workflow-configs.js';
+import { createTestDb } from './helpers/db.js';
+import { createMockEmitter } from './helpers/mock-emitter.js';
+import type { ParsedScope } from '../parsers/scope-parser.js';
+
+function makeScope(overrides: Partial<ParsedScope> & { id: number }): ParsedScope {
+  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,
+  };
+}
+
+describe('scope-routes', () => {
+  let app: express.Express;
+  let cleanup: () => void;
+
+  const testScopes = [
+    makeScope({ id: 1, title: 'First Scope' }),
+    makeScope({ id: 2, title: 'Second Scope' }),
+  ];
+
+  const mockScopeService = {
+    getAll: vi.fn().mockReturnValue(testScopes),
+    getById: vi.fn((id: number) => testScopes.find(s => s.id === id)),
+    updateStatus: vi.fn().mockReturnValue({ ok: true }),
+    updateFields: vi.fn().mockReturnValue({ ok: true }),
+    createIdeaFile: vi.fn().mockReturnValue({ slug: 'new-idea', title: 'New Idea' }),
+    updateIdeaFile: vi.fn().mockReturnValue(true),
+    deleteIdeaFile: vi.fn().mockReturnValue(true),
+    promoteIdea: vi.fn().mockReturnValue({ id: 10, filePath: '/scopes/planning/010-new.md', title: 'New', description: '' }),
+    approveGhostIdea: vi.fn().mockReturnValue(true),
+  };
+
+  const mockReadinessService = {
+    getReadiness: vi.fn((id: number) => id === 1 ? { scope_id: 1, transitions: [], blockers: [] } : null),
+  };
+
+  beforeAll(() => {
+    const { db, cleanup: c } = createTestDb();
+    cleanup = c;
+    const emitter = createMockEmitter();
+    const engine = new WorkflowEngine(DEFAULT_CONFIG);
+
+    const router = createScopeRoutes({
+      db,
+      io: emitter,
+      scopeService: mockScopeService as any,
+      readinessService: mockReadinessService as any,
+      projectRoot: '/tmp/test-project',
+      projectName: 'Test',
+      engine,
+    });
+
+    app = express();
+    app.use(express.json());
+    app.use('/api/orbital', router);
+  });
+
+  afterAll(() => cleanup?.());
+
+  describe('GET /scopes', () => {
+    it('returns all scopes', async () => {
+      const res = await request(app).get('/api/orbital/scopes');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(2);
+    });
+  });
+
+  describe('GET /scopes/:id', () => {
+    it('returns scope by ID', async () => {
+      const res = await request(app).get('/api/orbital/scopes/1');
+      expect(res.status).toBe(200);
+      expect(res.body.id).toBe(1);
+    });
+
+    it('returns 404 for unknown scope', async () => {
+      const res = await request(app).get('/api/orbital/scopes/999');
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('PATCH /scopes/:id', () => {
+    it('updates scope fields', async () => {
+      const res = await request(app)
+        .patch('/api/orbital/scopes/1')
+        .send({ title: 'Updated Title' });
+      expect(res.status).toBe(200);
+      expect(mockScopeService.updateFields).toHaveBeenCalled();
+    });
+  });
+
+  describe('PATCH /scopes/bulk/status', () => {
+    it('bulk updates scope statuses', async () => {
+      const res = await request(app)
+        .patch('/api/orbital/scopes/bulk/status')
+        .send({ scopes: [{ id: 1, status: 'implementing' }] });
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('POST /ideas', () => {
+    it('creates idea with title', async () => {
+      const res = await request(app)
+        .post('/api/orbital/ideas')
+        .send({ title: 'New Idea', description: 'A description' });
+      expect(res.status).toBe(201);
+      expect(res.body.slug).toBe('new-idea');
+    });
+
+    it('rejects empty title', async () => {
+      const res = await request(app)
+        .post('/api/orbital/ideas')
+        .send({ title: '  ', description: '' });
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('DELETE /ideas/:slug', () => {
+    it('deletes idea', async () => {
+      const res = await request(app).delete('/api/orbital/ideas/test-idea');
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('GET /scopes/:id/readiness', () => {
+    it('returns readiness for known scope', async () => {
+      const res = await request(app).get('/api/orbital/scopes/1/readiness');
+      expect(res.status).toBe(200);
+      expect(res.body.scope_id).toBe(1);
+    });
+
+    it('returns 404 for unknown scope', async () => {
+      const res = await request(app).get('/api/orbital/scopes/999/readiness');
+      expect(res.status).toBe(404);
+    });
+  });
+});

package/server/__tests__/sprint-routes.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createSprintRoutes } from '../routes/sprint-routes.js';
+
+describe('sprint-routes', () => {
+  let app: express.Express;
+
+  const mockSprintService = {
+    create: vi.fn().mockReturnValue({ id: 1, name: 'Sprint 1', status: 'assembling', scope_ids: [], scopes: [], layers: null, progress: { pending: 0, in_progress: 0, completed: 0, failed: 0, skipped: 0 } }),
+    getAll: vi.fn().mockReturnValue([]),
+    getById: vi.fn((id: number) => id === 1 ? { id: 1, name: 'Sprint 1', status: 'assembling', scope_ids: [], scopes: [] } : null),
+    rename: vi.fn().mockReturnValue(true),
+    delete: vi.fn().mockReturnValue(true),
+    addScopes: vi.fn().mockReturnValue({ added: [1, 2], unmet_dependencies: [] }),
+    removeScopes: vi.fn().mockReturnValue(true),
+  };
+
+  const mockSprintOrchestrator = {
+    startSprint: vi.fn().mockReturnValue({ ok: true, layers: [[1], [2]] }),
+    cancelSprint: vi.fn().mockReturnValue({ ok: true }),
+    getExecutionGraph: vi.fn().mockReturnValue({ nodes: [], edges: [] }),
+  };
+
+  const mockBatchOrchestrator = {
+    dispatch: vi.fn().mockReturnValue({ ok: true }),
+  };
+
+  beforeAll(() => {
+    const router = createSprintRoutes({
+      sprintService: mockSprintService as any,
+      sprintOrchestrator: mockSprintOrchestrator as any,
+      batchOrchestrator: mockBatchOrchestrator as any,
+    });
+
+    app = express();
+    app.use(express.json());
+    app.use('/api/orbital', router);
+  });
+
+  describe('POST /sprints', () => {
+    it('creates sprint with name (201)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/sprints')
+        .send({ name: 'New Sprint' });
+      expect(res.status).toBe(201);
+      expect(mockSprintService.create).toHaveBeenCalledWith('New Sprint', expect.anything());
+    });
+
+    it('rejects empty name (400)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/sprints')
+        .send({ name: '  ' });
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('GET /sprints', () => {
+    it('returns sprint list', async () => {
+      const res = await request(app).get('/api/orbital/sprints');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+    });
+
+    it('passes status filter', async () => {
+      await request(app).get('/api/orbital/sprints?status=assembling');
+      expect(mockSprintService.getAll).toHaveBeenCalledWith('assembling', undefined);
+    });
+  });
+
+  describe('PATCH /sprints/:id', () => {
+    it('renames sprint', async () => {
+      const res = await request(app)
+        .patch('/api/orbital/sprints/1')
+        .send({ name: 'Renamed' });
+      expect(res.status).toBe(200);
+    });
+
+    it('rejects missing name (400)', async () => {
+      const res = await request(app)
+        .patch('/api/orbital/sprints/1')
+        .send({});
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('DELETE /sprints/:id', () => {
+    it('deletes sprint', async () => {
+      const res = await request(app).delete('/api/orbital/sprints/1');
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('POST /sprints/:id/scopes', () => {
+    it('adds scopes to sprint', async () => {
+      const res = await request(app)
+        .post('/api/orbital/sprints/1/scopes')
+        .send({ scope_ids: [1, 2] });
+      expect(res.status).toBe(200);
+    });
+
+    it('rejects empty scope_ids (400)', async () => {
+      const res = await request(app)
+        .post('/api/orbital/sprints/1/scopes')
+        .send({ scope_ids: [] });
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('POST /sprints/:id/dispatch', () => {
+    it('dispatches sprint', async () => {
+      const res = await request(app)
+        .post('/api/orbital/sprints/1/dispatch')
+        .send({});
+      expect(res.status).toBe(200);
+    });
+  });
+});