:sparkles: (Go) select for channels

Go/racer/racer.go

···
+package racer
+
+import (
+    "fmt"
+    "net/http"
+    "time"
+)
+
+var tenSecondTimeout = 10 * time.Second
+
+func Racer(a, b string) (winner string, error error) {
+    return ConfigurableRacer(a, b, tenSecondTimeout)
+}
+
+func ConfigurableRacer(a, b string, timeout time.Duration) (winner string, error error) {
+    // allows to wait on multiple channels, the first to respond will be executed
+    select {
+    case <-ping(a):
+        return a, nil
+    case <-ping(b):
+        return b, nil
+    case <-time.After(timeout):
+        return "", fmt.Errorf("timed out waiting for %s and %s", a, b)
+    }
+}
+
+func measureResponseTime(url string) time.Duration {
+    start := time.Now()
+    http.Get(url)
+    return time.Since(start)
+}
+
+func ping(url string) chan struct{} {
+    ch := make(chan struct{})
+
+    go func() {
+        http.Get(url)
+        close(ch)
+    }()
+
+    return ch
+}

Go/racer/racer_test.go

···
+package racer
+
+import (
+    "net/http"
+    "net/http/httptest"
+    "testing"
+    "time"
+)
+
+func TestRacer(t *testing.T) {
+    t.Run("compares speed of servers, returning the url of the fastest one", func(t *testing.T) {
+        slowServer := makeDelayedServer(20 * time.Millisecond)
+        fastServer := makeDelayedServer(0 * time.Millisecond)
+
+        // Defer makes so that this instructions are executed at the end of the function
+        defer slowServer.Close()
+        defer fastServer.Close()
+
+        slowUrl := slowServer.URL
+        fastUrl := fastServer.URL
+
+        want := fastUrl
+        got, err := Racer(slowUrl, fastUrl)
+
+        if err != nil {
+            t.Fatalf("did not expect an error but got one %v", err)
+        }
+
+        if got != want {
+            t.Errorf("got %q, want %q", got, want)
+        }
+    })
+
+    t.Run("returns an error if a server doesn't respond within 10s", func(t *testing.T) {
+        server := makeDelayedServer(25 * time.Millisecond)
+
+        defer server.Close()
+
+        _, err := ConfigurableRacer(server.URL, server.URL, 20 * time.Millisecond)
+
+        if err == nil {
+            t.Errorf("expected an error but didn't get one")
+        }
+    })
+}
+
+func makeDelayedServer(delay time.Duration) *httptest.Server {
+    return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        time.Sleep(delay)
+        w.WriteHeader(http.StatusOK)
+    }))
+}