func TestWithHttptestWithSpecifiedPort(t *testing.T) {
router := New()
router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
l, _ := net.Listen("tcp", ":8033")
ts := httptest.Server{
Listener: l,
Config: &http.Server{Handler: router},
}
ts.Start()
defer ts.Close()
testRequest(t, "http://localhost:8033/example")
}
Ω([]string{"DELETE", "GET"}).Should(ContainElement(r.Method))
Ω(r.URL.Path).Should(Equal("/"))
agentCalled++
w.WriteHeader(status)
if r.Method == "GET" {
w.Write([]byte("{\"port\": 12345, \"password\": \"super-secret\"}"))
}
})
listener, err := net.Listen("tcp", hostAndPort)
Ω(err).ShouldNot(HaveOccurred())
server = httptest.NewUnstartedServer(handler)
server.Listener = listener
server.Start()
Eventually(isListeningChecker(hostAndPort)).Should(BeTrue())
})
AfterEach(func() {
server.Close()
Eventually(isListeningChecker(hostAndPort)).Should(BeFalse())
})
Describe("#Reset", func() {
Context("when the DELETE request is successful", func() {
BeforeEach(func() {
status = http.StatusOK
})
It("makes a DELETE request to the rootURL", func() {
Context("when the server is not running", func() {
It("errors when connecting", func(done Done) {
err := l.Start("ws://localhost:1234", "myApp", outputChan, stopChan)
Expect(err).To(HaveOccurred())
close(done)
}, 2)
})
Context("when the converter returns nil messages", func() {
BeforeEach(func() {
converter = func([]byte) ([]byte, error) { return nil, nil }
})
JustBeforeEach(func() {
ts.Start()
Eventually(func() bool {
resp, _ := http.Head(fmt.Sprintf("http://%s", ts.Listener.Addr()))
return resp != nil && resp.StatusCode == http.StatusOK
}).Should(BeTrue())
})
It("ignores nil messages received from the server", func() {
go l.Start(fmt.Sprintf("ws://%s", ts.Listener.Addr()), "myApp", outputChan, stopChan)
messageChan <- []byte("ignored")
Consistently(outputChan).ShouldNot(Receive())
Consistently(mockBatcher.BatchCounterInput).ShouldNot(BeCalled())
})
})
func testUpgradeWithCurl(t *testing.T, mode testUpgradeMode, lenient bool) {
if runtime.GOOS != "linux" {
t.Skip("skipping Docker test when not on Linux; requires --net which won't work with boot2docker anyway")
}
requireCurl(t)
const msg = "Hello from curl!\n"
var ts2 *httptest.Server
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Foo", "Bar")
w.Header().Set("Client-Proto", r.Proto)
io.WriteString(w, msg)
})
ts := httptest.NewUnstartedServer(handler)
switch mode {
case testUpgradeNoTLS:
ts.TLS = nil
default:
ts2 = httptest.NewUnstartedServer(handler)
ts2.TLS = nil
}
wrapped := UpgradeServer(ts.Config, &Server{
PermitProhibitedCipherSuites: lenient,
})
modes := make([]testUpgradeMode, 0, 2)
switch mode {
case testUpgradeNoTLS:
modes = append(modes, mode)
ts.Config = wrapped
ts.Start()
t.Logf("Running test server for curl to hit at: %s", ts.URL)
case testUpgradeDualTLS:
modes = append(modes, testUpgradeNoTLS)
fallthrough
default:
modes = append(modes, testUpgradeTLSOnly)
ts2.Config = wrapped
ts.TLS = ts.Config.TLSConfig // the httptest.Server has its own copy of this TLS config
ts.StartTLS()
ts2.Start()
defer ts2.Close()
t.Logf("Running test server for curl to hit at: %s and %s", ts.URL, ts2.URL)
}
defer ts.Close()
defer func() { testHookOnConn = nil }()
for _, mode := range modes {
var gotConn int32
testHookOnConn = func() { atomic.StoreInt32(&gotConn, 1) }
T := ts
if mode == testUpgradeNoTLS && ts2 != nil {
T = ts2
}
container := curl(t, "-D-", "--silent", "--http2", "--insecure", T.URL)
defer kill(container)
resc := make(chan interface{}, 1)
go func() {
res, err := dockerLogs(container)
if err != nil {
resc <- err
} else {
resc <- res
}
}()
select {
case res := <-resc:
if err, ok := res.(error); ok {
t.Fatal(err)
}
testDualUpgradeOutput(t, string(res.([]byte)), (T.TLS == nil),
"HTTP/2.0 200",
"foo:Bar",
"client-proto:HTTP/2",
msg)
case <-time.After(3 * time.Second):
t.Errorf("timeout waiting for curl")
}
if atomic.LoadInt32(&gotConn) == 0 {
t.Error("never saw an http2 connection")
}
}
}
