Update fetch testing

2025-01-18 04:03:21 -08:00 · 2018-05-28 11:41:53 +01:00
parent d73473d0f6
commit b31231ab0a
9 changed files with 449 additions and 281 deletions
--- a/vendor/github.com/johanbrandhorst/fetch/README.md
+++ b/vendor/github.com/johanbrandhorst/fetch/README.md
@@ -4,5 +4,30 @@ The Go http.Transport interface implemented over the WHATWG Fetch API using the
 ## Usage

 This package requires the Go WASM compilation target to be supported.
-See [my wasm-experiments repo](github.com/johanbrandhorst/wasm-experiments)
-for and example of its use.
+Short example:
+
+```go
+c := http.Client{
+    Transport: &fetch.Transport{},
+}
+resp, err := c.Get("https://api.github.com")
+if err != nil {
+    fmt.Println(err)
+    return
+}
+defer resp.Body.Close()
+b, err := ioutil.ReadAll(resp.Body)
+if err != nil {
+    fmt.Println(err)
+    return
+}
+fmt.Println(string(b))
+```
+
+See [my wasm-experiments repo](https://github.com/johanbrandhorst/wasm-experiments)
+for the full example of its use.
+
+## Attribution
+
+The code is largely based on the Fetch API implementation
+[in GopherJS](https://github.com/gopherjs/gopherjs/blob/8dffc02ea1cb8398bb73f30424697c60fcf8d4c5/compiler/natives/src/net/http/fetch.go).
--- a/vendor/github.com/johanbrandhorst/fetch/fetch.go
+++ b/vendor/github.com/johanbrandhorst/fetch/fetch.go
@@ -15,6 +15,124 @@ import (
 // Adapted for syscall/js from
 // https://github.com/gopherjs/gopherjs/blob/8dffc02ea1cb8398bb73f30424697c60fcf8d4c5/compiler/natives/src/net/http/fetch.go

+// Transport is a RoundTripper that is implemented using the WHATWG Fetch API.
+// It supports streaming response bodies.
+type Transport struct{}
+
+// RoundTrip performs a full round trip of a request.
+func (*Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+	headers := js.Global.Get("Headers").New()
+	for key, values := range req.Header {
+		for _, value := range values {
+			headers.Call("append", key, value)
+		}
+	}
+
+	ac := js.Global.Get("AbortController").New()
+
+	opt := js.Global.Get("Object").New()
+	opt.Set("headers", headers)
+	opt.Set("method", req.Method)
+	opt.Set("credentials", "same-origin")
+	opt.Set("signal", ac.Get("signal"))
+
+	var (
+		respCh = make(chan *http.Response, 1)
+		errCh  = make(chan error, 1)
+	)
+	if req.Body != nil {
+		/* Streaming request bodies are not supported yet
+		body := js.Global.Get("ReadableStream")
+		if body != js.Undefined {
+			source := js.Global.Get("Object").New()
+			// TODO(johanbrandhorst): Use ReadableByteStreamController.
+			// Currently Unsupported: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController#Browser_Compatibility
+			start := js.NewCallback(func(args []js.Value) {
+				fmt.Println("start called")
+				controller := args[0]
+				w := &streamWriter{controller: controller}
+				_, err := io.Copy(w, req.Body)
+				if err != nil {
+					errCh <- err
+					return
+				}
+			})
+			defer start.Close()
+			source.Set("start", start)
+			body = js.Global.Get("ReadableStream").New(source)
+		}
+		*/
+		content, err := ioutil.ReadAll(req.Body)
+		if err != nil {
+			req.Body.Close() // RoundTrip must always close the body, including on errors.
+			return nil, err
+		}
+		req.Body.Close()
+		opt.Set("body", js.ValueOf(content))
+	}
+	respPromise := js.Global.Call("fetch", req.URL.String(), opt)
+	if respPromise == js.Undefined {
+		return nil, errors.New("your browser does not support the Fetch API, please upgrade")
+	}
+
+	success := js.NewCallback(func(args []js.Value) {
+		result := args[0]
+		header := http.Header{}
+		writeHeaders := js.NewCallback(func(args []js.Value) {
+			key, value := args[0].String(), args[1].String()
+			ck := http.CanonicalHeaderKey(key)
+			header[ck] = append(header[ck], value)
+		})
+		defer writeHeaders.Close()
+		result.Get("headers").Call("forEach", writeHeaders)
+
+		contentLength := int64(-1)
+		if cl, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil {
+			contentLength = cl
+		}
+
+		b := result.Get("body")
+		var body io.ReadCloser
+		if b != js.Undefined {
+			body = &streamReader{stream: b.Call("getReader")}
+		} else {
+			// Fall back to using the arrayBuffer
+			// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer
+			body = &arrayReader{arrayPromise: result.Call("arrayBuffer")}
+		}
+		select {
+		case respCh <- &http.Response{
+			Status:        result.Get("status").String() + " " + http.StatusText(result.Get("status").Int()),
+			StatusCode:    result.Get("status").Int(),
+			Header:        header,
+			ContentLength: contentLength,
+			Body:          body,
+			Request:       req,
+		}:
+		case <-req.Context().Done():
+		}
+	})
+	defer success.Close()
+	failure := js.NewCallback(func(args []js.Value) {
+		select {
+		case errCh <- fmt.Errorf("net/http: fetch() failed: %s", args[0].String()):
+		case <-req.Context().Done():
+		}
+	})
+	defer failure.Close()
+	respPromise.Call("then", success, failure)
+	select {
+	case <-req.Context().Done():
+		// Abort the Fetch request
+		ac.Call("abort")
+		return nil, errors.New("net/http: request canceled")
+	case resp := <-respCh:
+		return resp, nil
+	case err := <-errCh:
+		return nil, err
+	}
+}
+
 // streamReader implements an io.ReadCloser wrapper for ReadableStream of https://fetch.spec.whatwg.org/.
 type streamReader struct {
 	pending []byte
@@ -24,25 +142,24 @@ type streamReader struct {
 func (r *streamReader) Read(p []byte) (n int, err error) {
 	if len(r.pending) == 0 {
 		var (
-			bCh   = make(chan []byte)
-			errCh = make(chan error)
-		)
-		r.stream.Call("read").Call("then",
-			js.NewCallback(func(args []js.Value) {
-				result := args[0]
-				if result.Get("done").Bool() {
-					errCh <- io.EOF
-					return
-				}
-				value := make([]byte, result.Get("value").Get("byteLength").Int())
-				js.ValueOf(value).Call("set", result.Get("value"))
-				bCh <- value
-			}),
-			js.NewCallback(func(args []js.Value) {
-				// Assumes it's a DOMException.
-				errCh <- errors.New(args[0].Get("message").String())
-			}),
+			bCh   = make(chan []byte, 1)
+			errCh = make(chan error, 1)
 		)
+		success := js.NewCallback(func(args []js.Value) {
+			result := args[0]
+			if result.Get("done").Bool() {
+				errCh <- io.EOF
+				return
+			}
+			bCh <- copyBytes(result.Get("value"))
+		})
+		defer success.Close()
+		failure := js.NewCallback(func(args []js.Value) {
+			// Assumes it's a DOMException.
+			errCh <- errors.New(args[0].Get("message").String())
+		})
+		defer failure.Close()
+		r.stream.Call("read").Call("then", success, failure)
 		select {
 		case b := <-bCh:
 			r.pending = b
@@ -63,93 +180,68 @@ func (r *streamReader) Close() error {
 	return nil
 }

-// Transport is a RoundTripper that is implemented using the WHATWG Fetch API.
-// It supports streaming response bodies.
-type Transport struct{}
-
-// RoundTrip performs a full round trip of a request.
-func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
-	headers := js.Global.Get("Headers").New()
-	for key, values := range req.Header {
-		for _, value := range values {
-			headers.Call("append", key, value)
-		}
-	}
-
-	ac := js.Global.Get("AbortController").New()
-
-	opt := js.Global.Get("Object").New()
-	opt.Set("headers", headers)
-	opt.Set("method", req.Method)
-	opt.Set("credentials", "same-origin")
-	opt.Set("signal", ac.Get("signal"))
-
-	if req.Body != nil {
-		body, err := ioutil.ReadAll(req.Body)
-		if err != nil {
-			_ = req.Body.Close() // RoundTrip must always close the body, including on errors.
-			return nil, err
-		}
-		_ = req.Body.Close()
-		opt.Set("body", body)
-	}
-	respPromise := js.Global.Call("fetch", req.URL.String(), opt)
-	if respPromise == js.Undefined {
-		return nil, errors.New("your browser does not support the Fetch API, please upgrade")
-	}
-
-	var (
-		respCh = make(chan *http.Response)
-		errCh  = make(chan error)
-	)
-	respPromise.Call("then",
-		js.NewCallback(func(args []js.Value) {
-			result := args[0]
-			header := http.Header{}
-			result.Get("headers").Call("forEach", js.NewCallback(func(args []js.Value) {
-				key, value := args[0].String(), args[1].String()
-				ck := http.CanonicalHeaderKey(key)
-				header[ck] = append(header[ck], value)
-			}))
-
-			contentLength := int64(-1)
-			if cl, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil {
-				contentLength = cl
-			}
-
-			b := result.Get("body")
-			if b == js.Undefined {
-				errCh <- errors.New("your browser does not support the ReadableStream API, please upgrade")
-				return
-			}
-
-			select {
-			case respCh <- &http.Response{
-				Status:        result.Get("status").String() + " " + http.StatusText(result.Get("status").Int()),
-				StatusCode:    result.Get("status").Int(),
-				Header:        header,
-				ContentLength: contentLength,
-				Body:          &streamReader{stream: b.Call("getReader")},
-				Request:       req,
-			}:
-			case <-req.Context().Done():
-			}
-		}),
-		js.NewCallback(func(args []js.Value) {
-			select {
-			case errCh <- fmt.Errorf("net/http: fetch() failed: %s", args[0].String()):
-			case <-req.Context().Done():
-			}
-		}),
-	)
-	select {
-	case <-req.Context().Done():
-		// Abort the Fetch request
-		ac.Call("abort")
-		return nil, errors.New("net/http: request canceled")
-	case resp := <-respCh:
-		return resp, nil
-	case err := <-errCh:
-		return nil, err
-	}
+// arrayReader implements an io.ReadCloser wrapper for arrayBuffer
+// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer.
+type arrayReader struct {
+	arrayPromise js.Value
+	pending      []byte
+	read         bool
+}
+
+func (r *arrayReader) Read(p []byte) (n int, err error) {
+	if !r.read {
+		r.read = true
+		var (
+			bCh   = make(chan []byte, 1)
+			errCh = make(chan error, 1)
+		)
+		success := js.NewCallback(func(args []js.Value) {
+			// Wrap the input ArrayBuffer with a Uint8Array
+			uint8arrayWrapper := js.Global.Get("Uint8Array").New(args[0])
+			bCh <- copyBytes(uint8arrayWrapper)
+		})
+		defer success.Close()
+		failure := js.NewCallback(func(args []js.Value) {
+			// Assumes it's a DOMException.
+			errCh <- errors.New(args[0].Get("message").String())
+		})
+		defer failure.Close()
+		r.arrayPromise.Call("then", success, failure)
+		select {
+		case b := <-bCh:
+			r.pending = b
+		case err := <-errCh:
+			return 0, err
+		}
+	}
+	if len(r.pending) == 0 {
+		return 0, io.EOF
+	}
+	n = copy(p, r.pending)
+	r.pending = r.pending[n:]
+	return n, nil
+}
+
+func (r *arrayReader) Close() error {
+	// This is a noop
+	return nil
+}
+
+/*
+// streamWriter exposes a ReadableStreamDefaultController as an io.Writer
+// https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultController
+type streamWriter struct {
+	controller js.Value
+}
+
+func (w *streamWriter) Write(p []byte) (int, error) {
+	w.controller.Call("enqueue", p)
+	return len(p), nil
+}
+*/
+
+func copyBytes(in js.Value) []byte {
+	value := make([]byte, in.Get("byteLength").Int())
+	js.ValueOf(value).Call("set", in)
+	return value
 }