redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/repl-extra.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Extra coverage for src/repl.ts
+ *
+ * Targets:
+ * - ReplSession.evaluate: top-level declarations, statements, empty input, error handling
+ * - ReplSession.clear
+ * - ReplSession.getSource
+ * - isTopLevelDeclaration (fn, struct, enum, decorated)
+ * - normalizeStatement (trailing semicolon)
+ * - selectRelevantFiles (declaration vs statement filtering)
+ * - formatFiles (no files, with files)
+ */
+
+import { ReplSession } from '../repl'
+
+describe('ReplSession — basic operations', () => {
+  test('empty input returns no files', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('')
+    expect(result.files).toEqual([])
+    expect(result.output).toBe('')
+  })
+
+  test('whitespace-only input returns no files', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('   \t  ')
+    expect(result.files).toEqual([])
+    expect(result.output).toBe('')
+  })
+
+  test('statement without trailing semicolon gets semicolon added', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('let x = 42')
+    // Should not throw, normalized with ;
+    expect(result.source).toContain('let x = 42;')
+  })
+
+  test('statement with trailing semicolon is kept as-is', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('let x = 5;')
+    expect(result.source).toContain('let x = 5;')
+  })
+
+  test('statement with trailing brace is kept as-is', () => {
+    const session = new ReplSession('test')
+    // A single-line if is unusual but tests the } terminator
+    const result = session.evaluate('if (1 > 0) { let y = 1; }')
+    expect(result.source).toContain('if (1 > 0) { let y = 1; }')
+  })
+
+  test('fn declaration is recognized as top-level', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('fn add(a: int, b: int): int { return a + b; }')
+    // Declaration goes to declarations list, not statements
+    expect(result.source).toContain('fn add(a: int, b: int): int')
+    // Should have some file output (not the __repl fn)
+    const hasAddFile = result.files.some(f => f.path.includes('add'))
+    expect(hasAddFile).toBe(true)
+  })
+
+  test('struct declaration is recognized as top-level', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('struct Point { x: int, y: int }')
+    expect(result.source).toContain('struct Point')
+  })
+
+  test('enum declaration is recognized as top-level', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('enum Color { Red, Green, Blue }')
+    expect(result.source).toContain('enum Color')
+  })
+
+  test('decorated fn is recognized as top-level', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('@tick fn tick_handler(): int { return 0; }')
+    expect(result.source).toContain('fn tick_handler')
+  })
+})
+
+describe('ReplSession — state accumulation', () => {
+  test('multiple statements accumulate in source', () => {
+    const session = new ReplSession('test')
+    session.evaluate('let a = 1;')
+    session.evaluate('let b = 2;')
+    const result = session.evaluate('let c = 3;')
+    expect(result.source).toContain('let a = 1;')
+    expect(result.source).toContain('let b = 2;')
+    expect(result.source).toContain('let c = 3;')
+  })
+
+  test('clear resets state', () => {
+    const session = new ReplSession('test')
+    session.evaluate('let x = 10;')
+    session.clear()
+    const result = session.evaluate('let y = 20;')
+    expect(result.source).not.toContain('let x = 10;')
+    expect(result.source).toContain('let y = 20;')
+  })
+
+  test('declaration followed by statement includes both', () => {
+    const session = new ReplSession('test')
+    session.evaluate('fn helper(): int { return 99; }')
+    const result = session.evaluate('let v = helper();')
+    expect(result.source).toContain('fn helper')
+    expect(result.source).toContain('let v = helper();')
+  })
+})
+
+describe('ReplSession — getSource', () => {
+  test('empty session generates fn __repl()', () => {
+    const session = new ReplSession('test')
+    const source = session.getSource()
+    expect(source).toContain('fn __repl()')
+  })
+
+  test('declarations appear before __repl fn', () => {
+    const session = new ReplSession('test')
+    session.evaluate('fn a(): int { return 1; }')
+    const source = session.getSource()
+    const fnAPos = source.indexOf('fn a()')
+    const replPos = source.indexOf('fn __repl()')
+    expect(fnAPos).toBeLessThan(replPos)
+  })
+})
+
+describe('ReplSession — evaluate with compilation', () => {
+  test('simple arithmetic expression compiles without error', () => {
+    const session = new ReplSession('test')
+    expect(() => session.evaluate('let x = 1 + 2;')).not.toThrow()
+  })
+
+  test('invalid expression throws error', () => {
+    const session = new ReplSession('test')
+    // Invalid syntax should throw
+    expect(() => session.evaluate('let x = +')).toThrow()
+  })
+
+  test('multiple declarations compile together', () => {
+    const session = new ReplSession('test')
+    session.evaluate('fn square(n: int): int { return n * n; }')
+    expect(() => session.evaluate('fn cube(n: int): int { return n * square(n); }')).not.toThrow()
+  })
+
+  test('file output contains mcfunction content for statement', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('let x = 42;')
+    // Some mcfunction files should be generated
+    const hasMcFunc = result.files.some(f => f.path.endsWith('.mcfunction'))
+    expect(hasMcFunc).toBe(true)
+  })
+
+  test('statement output is non-empty for valid code', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('let x = 42;')
+    // The output should have something or files should have content
+    const hasContent = result.output !== '' || result.files.length > 0
+    expect(hasContent).toBe(true)
+  })
+
+  test('output is formatted as path + content', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('let x = 1;')
+    if (result.output) {
+      expect(result.output).toContain('mcfunction')
+    }
+  })
+
+  test('custom namespace is used in paths', () => {
+    const session = new ReplSession('mypack')
+    const result = session.evaluate('let x = 5;')
+    if (result.files.length > 0) {
+      expect(result.files.some(f => f.path.includes('mypack'))).toBe(true)
+    }
+  })
+})
+
+describe('ReplSession — formatFiles "Accepted" path', () => {
+  test('struct declaration with no functions produces Accepted message', () => {
+    // A struct declaration that doesn't generate a standalone function file
+    // should still compile, and if files array is empty from selectRelevantFiles, 
+    // the output should contain 'Accepted'
+    const session = new ReplSession('test')
+    const result = session.evaluate('struct Empty { x: int }')
+    // Either output has Accepted or files exist
+    const hasOutput = result.output.includes('Accepted') || result.files.length > 0
+    expect(hasOutput).toBe(true)
+  })
+
+  test('enum declaration produces output or Accepted message', () => {
+    const session = new ReplSession('test')
+    const result = session.evaluate('enum Status { Active, Inactive }')
+    const hasOutput = result.output.length > 0 || result.files.length === 0
+    expect(hasOutput).toBe(true)
+  })
+})

package/src/__tests__/repl-server-extra.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Extra branch coverage for src/repl-server.ts
+ *
+ * Targets:
+ * - OPTIONS preflight → 204
+ * - 404 fallback for unknown URL
+ * - typeof code !== 'string' → 400
+ * - POST /compile without namespace (uses default)
+ */
+
+import * as http from 'http'
+import { requestHandler } from '../repl-server'
+
+// Use a different port from repl-server.test.ts (3000) to avoid port conflicts
+const PORT = 3001
+const server = http.createServer(requestHandler)
+
+function rawRequest(
+  method: string,
+  urlPath: string,
+  body?: string,
+  headers: http.OutgoingHttpHeaders = {}
+): Promise<{ status: number; headers: http.IncomingHttpHeaders; body: string }> {
+  return new Promise((resolve, reject) => {
+    const options: http.RequestOptions = {
+      hostname: '127.0.0.1',
+      port: PORT,
+      path: urlPath,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(body ? { 'Content-Length': Buffer.byteLength(body) } : {}),
+        ...headers,
+      },
+    }
+
+    const req = http.request(options, res => {
+      const chunks: Buffer[] = []
+      res.on('data', (c: Buffer) => chunks.push(c))
+      res.on('end', () => {
+        resolve({
+          status: res.statusCode ?? 0,
+          headers: res.headers,
+          body: Buffer.concat(chunks).toString('utf8'),
+        })
+      })
+    })
+    req.on('error', reject)
+    if (body) req.write(body)
+    req.end()
+  })
+}
+
+function jsonRequest(
+  method: string,
+  urlPath: string,
+  body?: unknown
+): Promise<{ status: number; body: unknown }> {
+  const payload = body !== undefined ? JSON.stringify(body) : undefined
+  return rawRequest(method, urlPath, payload).then(res => {
+    let parsed: unknown = {}
+    try { parsed = JSON.parse(res.body) } catch { /* empty body */ }
+    return { status: res.status, body: parsed }
+  })
+}
+
+beforeAll(done => {
+  if (server.listening) {
+    done()
+  } else {
+    server.listen(PORT, done)
+  }
+})
+
+afterAll(done => {
+  server.close(done)
+})
+
+// ── OPTIONS preflight ─────────────────────────────────────────────────────
+
+describe('OPTIONS /compile — CORS preflight', () => {
+  it('returns 204 with CORS headers', async () => {
+    const res = await rawRequest('OPTIONS', '/compile')
+    expect(res.status).toBe(204)
+    expect(res.headers['access-control-allow-origin']).toBe('*')
+    expect(res.headers['access-control-allow-methods']).toContain('POST')
+  })
+
+  it('OPTIONS on other paths also returns 204 preflight', async () => {
+    const res = await rawRequest('OPTIONS', '/health')
+    expect(res.status).toBe(204)
+  })
+})
+
+// ── 404 fallback ─────────────────────────────────────────────────────────
+
+describe('Unknown routes — 404', () => {
+  it('GET /unknown returns 404', async () => {
+    const res = await jsonRequest('GET', '/unknown')
+    expect(res.status).toBe(404)
+  })
+
+  it('DELETE /compile returns 404', async () => {
+    const res = await jsonRequest('DELETE', '/compile')
+    expect(res.status).toBe(404)
+  })
+
+  it('GET /compile returns 404 (only POST allowed)', async () => {
+    const res = await jsonRequest('GET', '/compile')
+    expect(res.status).toBe(404)
+  })
+})
+
+// ── typeof code !== 'string' ──────────────────────────────────────────────
+
+describe('POST /compile — non-string code field', () => {
+  it('returns 400 when code is a number', async () => {
+    const res = await jsonRequest('POST', '/compile', { code: 42 })
+    expect(res.status).toBe(400)
+    expect((res.body as { error: string }).error).toContain('"code"')
+  })
+
+  it('returns 400 when code is null', async () => {
+    const res = await jsonRequest('POST', '/compile', { code: null })
+    expect(res.status).toBe(400)
+  })
+
+  it('returns 400 when code is an array', async () => {
+    const res = await jsonRequest('POST', '/compile', { code: ['fn f() {}'] })
+    expect(res.status).toBe(400)
+  })
+
+  it('returns 400 when code is an object', async () => {
+    const res = await jsonRequest('POST', '/compile', { code: { text: 'fn f() {}' } })
+    expect(res.status).toBe(400)
+  })
+})
+
+// ── POST /compile without namespace (uses default) ────────────────────────
+
+describe('POST /compile — optional namespace', () => {
+  it('compiles without namespace field using default', async () => {
+    const res = await jsonRequest('POST', '/compile', { code: 'fn f(): int { return 1; }' })
+    expect(res.status).toBe(200)
+    const body = res.body as { files: { path: string; content: string }[] }
+    expect(Array.isArray(body.files)).toBe(true)
+    // Default namespace is 'redscript'
+    expect(body.files.some(f => f.path.includes('redscript'))).toBe(true)
+  })
+})

package/src/__tests__/repl-server.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Tests for the RedScript REPL HTTP server.
+ *
+ * The server is started once for all tests (beforeAll) and closed after (afterAll).
+ */
+
+import * as http from 'http'
+import { server } from '../repl-server'
+
+const PORT = 3000
+
+function request(
+  method: string,
+  path: string,
+  body?: unknown
+): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const payload = body !== undefined ? JSON.stringify(body) : undefined
+    const options: http.RequestOptions = {
+      hostname: '127.0.0.1',
+      port: PORT,
+      path,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(payload ? { 'Content-Length': Buffer.byteLength(payload) } : {}),
+      },
+    }
+
+    const req = http.request(options, res => {
+      const chunks: Buffer[] = []
+      res.on('data', (chunk: Buffer) => chunks.push(chunk))
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+          resolve({ status: res.statusCode ?? 0, body: parsed })
+        } catch {
+          reject(new Error('Failed to parse response JSON'))
+        }
+      })
+    })
+    req.on('error', reject)
+    if (payload) req.write(payload)
+    req.end()
+  })
+}
+
+beforeAll(done => {
+  // If the server is already listening (e.g. imported elsewhere), just proceed.
+  if (server.listening) {
+    done()
+  } else {
+    server.listen(PORT, done)
+  }
+})
+
+afterAll(done => {
+  server.close(done)
+})
+
+describe('GET /health', () => {
+  it('returns { ok: true }', async () => {
+    const res = await request('GET', '/health')
+    expect(res.status).toBe(200)
+    expect(res.body).toEqual({ ok: true })
+  })
+})
+
+describe('POST /compile', () => {
+  it('returns files for valid RedScript code', async () => {
+    const code = `fn hello() {\n  say("Hello, world!")\n}\n`
+    const res = await request('POST', '/compile', { code, namespace: 'test' })
+    expect(res.status).toBe(200)
+    const body = res.body as { files: { path: string; content: string }[]; error?: string }
+    expect(body.error).toBeUndefined()
+    expect(Array.isArray(body.files)).toBe(true)
+    expect(body.files.length).toBeGreaterThan(0)
+    expect(body.files[0]).toHaveProperty('path')
+    expect(body.files[0]).toHaveProperty('content')
+  })
+
+  it('returns error for invalid RedScript code', async () => {
+    const code = `fn broken( { this is not valid redscript !!!`
+    const res = await request('POST', '/compile', { code, namespace: 'test' })
+    expect(res.status).toBe(200)
+    const body = res.body as { files: unknown[]; error?: string }
+    expect(typeof body.error).toBe('string')
+    expect(body.error!.length).toBeGreaterThan(0)
+  })
+
+  it('returns 400 for missing code field', async () => {
+    const res = await request('POST', '/compile', { namespace: 'test' })
+    expect(res.status).toBe(400)
+  })
+
+  it('returns 400 for invalid JSON', async () => {
+    const res = await new Promise<{ status: number; body: unknown }>((resolve, reject) => {
+      const payload = 'not-json'
+      const options: http.RequestOptions = {
+        hostname: '127.0.0.1',
+        port: PORT,
+        path: '/compile',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+      }
+      const req = http.request(options, res => {
+        const chunks: Buffer[] = []
+        res.on('data', (c: Buffer) => chunks.push(c))
+        res.on('end', () => {
+          resolve({ status: res.statusCode ?? 0, body: JSON.parse(Buffer.concat(chunks).toString()) })
+        })
+      })
+      req.on('error', reject)
+      req.write(payload)
+      req.end()
+    })
+    expect(res.status).toBe(400)
+  })
+})