goscript 0.1.1 → 0.1.3

package/gs/net/http/httptest/index.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  Handler,
+  Header_Get,
+  Header_Set,
+  MethodGet,
+  NewRequest,
+  StatusPartialContent,
+} from '../index.js'
+import { NewServer, NewUnstartedServer, Server_Start } from './index.js'
+
+describe('net/http/httptest override', () => {
+  it('exports server helpers for typechecked server tests', () => {
+    const handler: Handler = {
+      ServeHTTP: () => undefined,
+    }
+
+    const srv = NewServer(handler)
+    expect(srv.URL).toMatch(/^http:\/\/goscript-httptest-\d+\.invalid$/)
+    expect(srv.Client()).toBeTruthy()
+    expect(srv.Config().Handler).toBe(handler)
+    expect(Server_Start(NewUnstartedServer(handler))?.Error()).toBe(
+      'net/http/httptest: Server.Start is not implemented in GoScript',
+    )
+    srv.Close()
+  })
+
+  it('routes Client.Do through the in-memory server handler', async () => {
+    const srv = NewServer({
+      ServeHTTP(w, r) {
+        Header_Set(w!.Header(), 'Content-Range', 'bytes 0-3/4')
+        const range = Header_Get($.pointerValue(r)!.Header, 'Range')
+        if (range !== 'bytes=0-3') {
+          w!.WriteHeader(400)
+          w!.Write($.stringToBytes(range))
+          return
+        }
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('data'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/pack.kvf', null)
+    expect(reqErr).toBeNull()
+    Header_Set(req!.Header, 'Range', 'bytes=0-3')
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    expect(Header_Get(resp!.Header, 'Content-Range')).toBe('bytes 0-3/4')
+    const buf = new Uint8Array(4)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(4)
+    expect(Buffer.from(buf).toString('utf8')).toBe('data')
+    expect(resp!.Body!.Close()).toBeNull()
+    srv.Close()
+  })
+
+  it('awaits async handlers through Server.Client transport', async () => {
+    const srv = NewServer({
+      async ServeHTTP(w) {
+        await Promise.resolve()
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('async'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/async', null)
+    expect(reqErr).toBeNull()
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    const buf = new Uint8Array(5)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('async')
+    srv.Close()
+  })
+})

package/gs/net/http/httptest/index.ts

@@ -1,25 +1,135 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
+import * as errors from '@goscript/errors/index.js'
 import * as http from '@goscript/net/http/index.js'
+import * as io from '@goscript/io/index.js'
+
+class responseBody implements io.ReadCloser {
+  private reader: bytes.Reader
+
+  constructor(data: $.Bytes) {
+    this.reader = bytes.NewReader(Uint8Array.from(data ?? []))
+  }
+
+  public Read(p: $.Bytes): [number, $.GoError] {
+    return this.reader.Read(p)
+  }
+
+  public Close(): $.GoError {
+    return null
+  }
+}
 
 export class ResponseRecorder implements http.ResponseWriter {
   public Code = 200
-  public Body: $.Slice<number> = null
+  public Body = new bytes.Buffer()
   private headerMap = new http.Header()
+  private wroteHeader = false
 
   public Header(): http.Header {
     return this.headerMap
   }
 
   public Write(p: $.Slice<number>): [number, $.GoError] {
-    this.Body = $.append(this.Body, p)
-    return [$.len(p), null]
+    if (!this.wroteHeader) {
+      this.WriteHeader(http.StatusOK)
+    }
+    return this.Body.Write(p)
   }
 
   public WriteHeader(statusCode: number): void {
+    if (this.wroteHeader) {
+      return
+    }
+    this.wroteHeader = true
     this.Code = statusCode
   }
+
+  public Result(): http.Response {
+    return new http.Response({
+      Body: new responseBody(this.Body.Bytes()),
+      Header: this.headerMap,
+      StatusCode: this.Code,
+    })
+  }
 }
 
 export function NewRecorder(): ResponseRecorder {
   return new ResponseRecorder()
 }
+
+export function NewRequest(
+  method: string,
+  target: string,
+  body: io.Reader | null,
+): http.Request {
+  const [req, err] = http.NewRequest(method, target, body)
+  if (err != null || req == null) {
+    throw (
+      err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+    )
+  }
+  return req
+}
+
+export class Server {
+  public URL: string
+  private handler: http.Handler | null
+
+  constructor(init?: Partial<Server> & { Handler?: http.Handler | null }) {
+    this.handler = init?.Handler ?? null
+    this.URL = init?.URL ?? http.RegisterInProcessServer(this.handler)
+  }
+
+  public Client(): http.Client {
+    return new http.Client({ Transport: new serverTransport(this) })
+  }
+
+  public Close(): void {
+    http.UnregisterInProcessServer(this.URL)
+  }
+
+  public Config(): http.Server {
+    return new http.Server({ Handler: this.handler })
+  }
+
+  public ServeHTTP(
+    w: http.ResponseWriter | null,
+    r: http.Request | $.VarRef<http.Request> | null,
+  ): void | Promise<void> {
+    return this.handler?.ServeHTTP(w, r)
+  }
+}
+
+class serverTransport implements http.RoundTripper {
+  constructor(private server: Server) {}
+
+  public async RoundTrip(
+    req: http.Request | $.VarRef<http.Request> | null,
+  ): Promise<[http.Response | null, $.GoError]> {
+    const request = $.pointerValue<http.Request | null>(req)
+    if (request == null) {
+      return [null, errors.New('net/http: nil Request')]
+    }
+    const recorder = NewRecorder()
+    const served = this.server.ServeHTTP(recorder, request)
+    if (served instanceof Promise) {
+      await served
+    }
+    return [recorder.Result(), null]
+  }
+}
+
+export function NewServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function NewUnstartedServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function Server_Start(_s: Server | $.VarRef<Server> | null): $.GoError {
+  return errors.New(
+    'net/http/httptest: Server.Start is not implemented in GoScript',
+  )
+}

package/gs/net/http/index.test.ts

@@ -1,6 +1,38 @@
 import { describe, expect, it } from 'vitest'
 
-import { Get, Response, StatusOK, StatusText } from './index.js'
+import { varRef } from '../../builtin/varRef.js'
+import {
+  Client,
+  DefaultTransport,
+  File,
+  FileSystem,
+  Header,
+  Header_Add,
+  Header_Del,
+  Header_Get,
+  Header_Set,
+  HandlerFunc_ServeHTTP,
+  Get,
+  MethodPost,
+  MethodDelete,
+  NewRequest,
+  NotFound,
+  ParseTime,
+  Response,
+  ResponseWriter,
+  Server,
+  StatusCreated,
+  StatusForbidden,
+  StatusMethodNotAllowed,
+  StatusNotFound,
+  StatusOK,
+  StatusServiceUnavailable,
+  StatusTeapot,
+  StatusText,
+  StatusTooManyRequests,
+  StatusUnauthorized,
+  StatusUnsupportedMediaType,
+} from './index.js'
 
 describe('net/http override', () => {
   it('exports response status helpers', () => {
@@ -8,7 +40,18 @@ describe('net/http override', () => {
 
     expect(resp.StatusCode).toBe(200)
     expect(StatusText(resp.StatusCode)).toBe('OK')
+    expect(StatusText(StatusNotFound)).toBe('Not Found')
+    expect(StatusText(StatusUnauthorized)).toBe('Unauthorized')
+    expect(StatusText(StatusForbidden)).toBe('Forbidden')
+    expect(StatusText(StatusMethodNotAllowed)).toBe('Method Not Allowed')
+    expect(StatusText(StatusUnsupportedMediaType)).toBe('Unsupported Media Type')
+    expect(StatusText(StatusTeapot)).toBe("I'm a teapot")
+    expect(StatusText(StatusTooManyRequests)).toBe('Too Many Requests')
+    expect(StatusText(StatusServiceUnavailable)).toBe('Service Unavailable')
     expect(StatusText(599)).toBe('')
+    expect(MethodPost).toBe('POST')
+    expect(MethodDelete).toBe('DELETE')
+    expect(StatusCreated).toBe(201)
   })
 
   it('returns an explicit unsupported error for Get', () => {
@@ -17,4 +60,119 @@ describe('net/http override', () => {
     expect(resp).toBeNull()
     expect(err?.Error()).toBe('net/http: Get is not implemented in GoScript')
   })
+
+  it('accepts VarRef requests for client calls', async () => {
+    const [req, reqErr] = NewRequest(MethodPost, 'https://example.invalid', null)
+    expect(reqErr).toBeNull()
+    expect((req!.URL as any).Path).toBe('/')
+    expect(req!.RequestURI).toBe('/')
+
+    const [resp, err] = await new Client().Do(varRef(req!))
+    expect(resp).toBeNull()
+    expect(err?.Error()).toBe('net/http: Client.Do is not implemented in GoScript')
+  })
+
+  it('exports the default transport surface', async () => {
+    const [req] = NewRequest(MethodPost, 'https://example.invalid', null)
+
+    const [resp, err] = await DefaultTransport.RoundTrip(req)
+
+    expect(resp).toBeNull()
+    expect(err?.Error()).toBe('net/http: Client.Do is not implemented in GoScript')
+  })
+
+  it('delegates client calls through RoundTripper implementations', async () => {
+    const [req] = NewRequest(MethodPost, 'https://example.invalid/path', null)
+    Header_Set(req!.Header, 'User-Agent', 'goscript-test')
+    req!.RemoteAddr = '127.0.0.1:1234'
+    req!.ContentLength = 42
+
+    const client = new Client({
+      Transport: {
+        RoundTrip: (got) => {
+          const request = (got as any).value ?? got
+          expect(request.UserAgent()).toBe('goscript-test')
+          expect(request.RemoteAddr).toBe('127.0.0.1:1234')
+          expect(request.RequestURI).toBe('/path')
+          expect(request.ContentLength).toBe(42)
+          return [new Response({ StatusCode: StatusOK }), null]
+        },
+      },
+    })
+
+    const [resp, err] = await client.Do(varRef(req!))
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusOK)
+  })
+
+  it('canonicalizes header keys for case-insensitive lookup', () => {
+    const header = new Header()
+
+    Header_Set(header, 'Content-Type', 'application/json')
+
+    expect(header.has('Content-Type')).toBe(true)
+    expect(header.has('content-type')).toBe(false)
+    expect(Header_Get(header, 'content-type')).toBe('application/json')
+
+    Header_Add(header, 'x-pack-id', 'pack-1')
+    Header_Add(header, 'X-Pack-Id', 'pack-2')
+    expect(Array.from(header.get('X-Pack-Id') ?? [])).toEqual(['pack-1', 'pack-2'])
+
+    Header_Del(header, 'x-pack-id')
+    expect(Header_Get(header, 'X-Pack-ID')).toBe('')
+  })
+
+  it('accepts server context and shutdown surfaces', () => {
+    const srv = new Server({
+      Addr: ':0',
+      BaseContext: () => ({} as any),
+      ReadHeaderTimeout: 10,
+    })
+
+    expect(srv.Addr).toBe(':0')
+    expect(srv.BaseContext?.(null)).toEqual({})
+    expect(srv.ReadHeaderTimeout).toBe(10)
+    expect(srv.Shutdown({} as any)).toBeNull()
+    expect(srv.ListenAndServeTLS('cert.pem', 'key.pem')?.Error()).toBe('net/http: Server.ListenAndServeTLS is not implemented in GoScript')
+  })
+
+  it('supports handler functions and not-found responses for typechecked server tests', () => {
+    const writes: string[] = []
+    const writer: ResponseWriter = {
+      Header: () => new Header(),
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+
+    HandlerFunc_ServeHTTP((_w, _r) => undefined, writer, null)
+    NotFound(writer, null)
+
+    expect(writes).toEqual(['status:404', '404 page not found\n'])
+  })
+
+  it('parses HTTP dates', () => {
+    const [parsed, err] = ParseTime('Sun, 06 Nov 1994 08:49:37 GMT')
+
+    expect(err).toBeNull()
+    expect(parsed.Unix()).toBe(784111777)
+  })
+
+  it('exports file server interface shapes', () => {
+    const file: File = {
+      Close: () => null,
+      Read: (p) => [p?.length ?? 0, null],
+      Seek: (offset) => [offset, null],
+      Readdir: () => [null, null],
+      Stat: () => [null, null],
+    }
+    const fsys: FileSystem = {
+      Open: (name) => (name === 'ok' ? [file, null] : [null, new Error('missing')]),
+    }
+
+    expect(fsys.Open('ok')[0]).toBe(file)
+    expect(fsys.Open('missing')[1]?.message).toBe('missing')
+  })
 })