func TestListProjectsThroughChannel(t *testing.T) { page := 0 var ts *httptest.Server ts = httptest.NewServer(authenticated(t, "GET", "/projects", func(w http.ResponseWriter, r *http.Request) { page += 1 if page < 10 { w.Header().Set("Link", fmt.Sprintf("<%s%s?page=%d>; rel=\"next\"", ts.URL, r.URL.Path, page+1)) } response(array_of_projects)(w, r) })) defer ts.Close() f := letsTestFreckle(ts) pp, err := f.ProjectsAPI().ListProjects() assert.Nil(t, err, "Error should be nil") projects := 0 // reading through the channel should do 10 HTTP request, yielding 1 project each for _ = range pp.AllProjects() { projects += 1 } assert.Equal(t, 10, projects, "Should have read 10 projects") assert.Equal(t, 10, page, "We should have read up to page 10") }
func TestGetData(t *testing.T) { var err error var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) w.Write([]byte("1 2 3 4 5")) })) defer ts.Close() i := 0 writer := JsonWriteFunc(func(d json.RawMessage) error { i++ return nil }) n, err := getData(ts.URL, writer, nil) if err != nil { t.Error(err) } if n != 5 { t.Error("n != 5") } if i != 5 { t.Error("i != 5") } }
func TestHTTPAuth(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) { from, err := HostPortToIP(r.RemoteAddr) if err != nil { t.Fatal(err) } to := ts.Listener.Addr() uid, err := AddrPairUserid(from, to) if err != nil { fmt.Fprintf(rw, "ERR: %v", err) return } fmt.Fprintf(rw, "uid=%d", uid) })) defer ts.Close() res, err := http.Get(ts.URL) if err != nil { t.Fatal(err) } body, err := ioutil.ReadAll(res.Body) if err != nil { t.Fatal(err) } if g, e := string(body), fmt.Sprintf("uid=%d", os.Getuid()); g != e { t.Errorf("got body %q; want %q", g, e) } }
func TestSubmitTasks(t *testing.T) { var err error var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(201) })) defer ts.Close() TASKS_ADDRESS = ts.URL + "/%s/tasks" i := 0 reader := JsonReaderFunc(func(d *json.RawMessage) error { if i == 5 { return io.EOF } i++ data := json.RawMessage("1") d = &data return nil }) n, err := SubmitTasks("", reader) if err != nil { t.Error(err) } if n != 5 { t.Error("n != 5") } }
func TestSuperviceReadLimit(t *testing.T) { buf.Reset() var server *httptest.Server var h http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) { fmt.Fprintln(w, "0123456789") } server = httptest.NewServer(h) defer server.Close() s := make(Services) s["s 1"] = &Service{ Name: "s 1", URL: server.URL, ReadLimit: 5, Expect: Expect{ Status: 200, }, } ez := &Epazote{ Services: s, } ez.debug = true ez.Supervice(s["s 1"])() rc := s["s 1"].retryCount if rc != 0 { t.Errorf("Expecting retryCount = 0 got: %d", rc) } data := buf.String() re := regexp.MustCompile("(?m)[\r\n]+^01234$") match := re.FindString(data) if match == "" { t.Error("Expecting: 01234") } }
func init() { suite := &routertest.RouterSuite{ SetUpSuiteFunc: func(c *check.C) { config.Set("routers:galeb:username", "myusername") config.Set("routers:galeb:password", "mypassword") config.Set("routers:galeb:domain", "galeb.com") config.Set("routers:galeb:type", "galeb") config.Set("database:url", "127.0.0.1:27017") config.Set("database:name", "router_galebv2_tests") }, } var server *httptest.Server suite.SetUpTestFunc = func(c *check.C) { handler, err := NewFakeGalebServer() c.Assert(err, check.IsNil) server = httptest.NewServer(handler) config.Set("routers:galeb:api-url", server.URL+"/api") gRouter, err := createRouter("routers:galeb") c.Assert(err, check.IsNil) suite.Router = gRouter conn, err := db.Conn() c.Assert(err, check.IsNil) defer conn.Close() dbtest.ClearAllCollections(conn.Collection("router_galebv2_tests").Database) } suite.TearDownTestFunc = func(c *check.C) { server.Close() } check.Suite(suite) }
func teardown(server *httptest.Server) { server.Close() // Cleanup cache files. er := os.RemoveAll("./raincollector") if er != nil { panic(er.Error()) } }
func testRedirectsByMethod(t *testing.T, method string, table []redirectTest, want string) { defer afterTest(t) var log struct { sync.Mutex bytes.Buffer } var ts *httptest.Server ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { log.Lock() slurp, _ := ioutil.ReadAll(r.Body) fmt.Fprintf(&log.Buffer, "%s %s %q\n", r.Method, r.RequestURI, slurp) log.Unlock() urlQuery := r.URL.Query() if v := urlQuery.Get("code"); v != "" { location := ts.URL if final := urlQuery.Get("next"); final != "" { splits := strings.Split(final, ",") first, rest := splits[0], splits[1:] location = fmt.Sprintf("%s?code=%s", location, first) if len(rest) > 0 { location = fmt.Sprintf("%s&next=%s", location, strings.Join(rest, ",")) } } code, _ := strconv.Atoi(v) if code/100 == 3 { w.Header().Set("Location", location) } w.WriteHeader(code) } })) defer ts.Close() for _, tt := range table { content := tt.redirectBody req, _ := NewRequest(method, ts.URL+tt.suffix, strings.NewReader(content)) req.GetBody = func() (io.ReadCloser, error) { return ioutil.NopCloser(strings.NewReader(content)), nil } res, err := DefaultClient.Do(req) if err != nil { t.Fatal(err) } if res.StatusCode != tt.want { t.Errorf("POST %s: status code = %d; want %d", tt.suffix, res.StatusCode, tt.want) } } log.Lock() got := log.String() log.Unlock() got = strings.TrimSpace(got) want = strings.TrimSpace(want) if got != want { t.Errorf("Log differs.\n Got:\n%s\nWant:\n%s\n", got, want) } }
func TestRedirectCookiesJar(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(echoCookiesRedirectHandler) defer ts.Close() c := &Client{} c.Jar = &TestJar{perURL: make(map[string][]*Cookie)} u, _ := url.Parse(ts.URL) c.Jar.SetCookies(u, []*Cookie{expectedCookies[0]}) resp, _ := c.Get(ts.URL) matchReturnedCookies(t, expectedCookies, resp.Cookies()) }
func TestFeedManagerDetection(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.RequestURI == "/link" { w.WriteHeader(http.StatusOK) w.Write([]byte(strings.Replace(atomXml, "{{ .FeedLink }}", ts.URL+"/link", -1))) } else if r.RequestURI == "/html" { w.Write([]byte(` <html> <head> <link type="text/css" href="/foo.css"> <link rel="alternative" type="application/rss+xml" href="/link"/> </head> <body><main></main></body> </html> `)) } else { w.WriteHeader(http.StatusNotFound) } })) defer ts.Close() _, err := discoverParserFeeds(ts.URL) if err == nil { t.Fatalf("Expected an ErrNoFeed error, got nothing\n") } else if err != ErrNoFeed { t.Fatalf("Expected an ErrNoFeed error, got %v\n", err) } pf, err := discoverParserFeeds(ts.URL + "/link") if err != nil { t.Fatal(err) } expectedStr := ts.URL + "/link" if pf[0].Link != expectedStr { t.Fatalf("Expected '%s' for a url, got '%s'\n", expectedStr, pf[0].Link) } pf, err = discoverParserFeeds(ts.URL + "/html") if err != nil { t.Fatal(err) } expectedStr = ts.URL + "/link" if pf[0].Link != expectedStr { t.Fatalf("Expected '%s' for a url, got '%s'\n", expectedStr, pf[0].Link) } }
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") }
func TestFetchCertBreadth(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { for i := 0; i < maxChainLen+1; i++ { w.Header().Add("link", fmt.Sprintf("<%s>;rel=up", ts.URL)) } w.Write([]byte{1}) })) defer ts.Close() _, err := (&Client{}).FetchCert(context.Background(), ts.URL, true) if err == nil { t.Errorf("err is nil") } }
func TestProvider(t *testing.T) { var ( h *httptest.Server g *httptest.Server ) header := `-----> Fetching archive link for ejholmes/acme-inc@abcd... done. -----> Deploying to acme-inc... ` logs := "Hello" h = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Logf("%s %s", r.Method, r.URL.Path) switch r.URL.Path { case "/apps/acme-inc/builds": fmt.Fprintf(w, `{"id": "1234", "output_stream_url": "%s/stream"}`, h.URL) case "/stream": fmt.Fprintf(w, logs) case "/apps/acme-inc/builds/1234/result": fmt.Fprintf(w, `{"build":{"status":"succeeded"}}`) } })) g = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Location", "http://github.com/archive") w.WriteHeader(302) })) defer h.Close() defer g.Close() p := NewProvider("", "") p.heroku.URL = h.URL p.github.BaseURL = mustURLParse(g.URL) d := &tugboat.Deployment{ Repo: "ejholmes/acme-inc", Environment: "production", Sha: "abcd", } w := new(bytes.Buffer) if err := p.Deploy(context.Background(), d, w); err != nil { t.Fatal(err) } if got, want := w.String(), header+logs; got != want { t.Fatalf("Logs => %s; want %s", got, want) } }
func TestRedirectCookiesJar(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(echoCookiesRedirectHandler) defer ts.Close() c := &http.Client{ Jar: new(TestJar), } u, _ := url.Parse(ts.URL) c.Jar.SetCookies(u, []*http.Cookie{expectedCookies[0]}) resp, err := c.Get(ts.URL) if err != nil { t.Fatalf("Get: %v", err) } matchReturnedCookies(t, expectedCookies, resp.Cookies()) }
func TestRedirectCookiesOnRequest(t *testing.T) { var ts *httptest.Server ts = httptest.NewServer(echoCookiesRedirectHandler) defer ts.Close() c := &Client{} req, _ := NewRequest("GET", ts.URL, nil) req.AddCookie(expectedCookies[0]) // TODO: Uncomment when an implementation of a RFC6265 cookie jar lands. _ = c // resp, _ := c.Do(req) // matchReturnedCookies(t, expectedCookies, resp.Cookies()) req, _ = NewRequest("GET", ts.URL, nil) // resp, _ = c.Do(req) // matchReturnedCookies(t, expectedCookies[1:], resp.Cookies()) }
func TestDeleteJobs(t *testing.T) { var err error var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(204) })) defer ts.Close() JOBS_ADDRESS = ts.URL err = DeleteJobs() if err != nil { t.Error(err) } }
func TestPostRedirects(t *testing.T) { defer afterTest(t) var log struct { sync.Mutex bytes.Buffer } var ts *httptest.Server ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { log.Lock() fmt.Fprintf(&log.Buffer, "%s %s ", r.Method, r.RequestURI) log.Unlock() if v := r.URL.Query().Get("code"); v != "" { code, _ := strconv.Atoi(v) if code/100 == 3 { w.Header().Set("Location", ts.URL) } w.WriteHeader(code) } })) defer ts.Close() tests := []struct { suffix string want int // response code }{ {"/", 200}, {"/?code=301", 301}, {"/?code=302", 200}, {"/?code=303", 200}, {"/?code=404", 404}, } for _, tt := range tests { res, err := Post(ts.URL+tt.suffix, "text/plain", strings.NewReader("Some content")) if err != nil { t.Fatal(err) } if res.StatusCode != tt.want { t.Errorf("POST %s: status code = %d; want %d", tt.suffix, res.StatusCode, tt.want) } } log.Lock() got := log.String() log.Unlock() want := "POST / POST /?code=301 POST /?code=302 GET / POST /?code=303 GET / POST /?code=404 " if got != want { t.Errorf("Log differs.\n Got: %q\nWant: %q", got, want) } }
func TestGoogleProviderGetEmailAddressInvalidEncoding(t *testing.T) { p := newGoogleProvider() body, err := json.Marshal(redeemResponse{ AccessToken: "a1234", IdToken: "ignored prefix." + `{"email": "*****@*****.**"}`, }) assert.Equal(t, nil, err) var server *httptest.Server p.RedeemUrl, server = newRedeemServer(body) defer server.Close() session, err := p.Redeem("http://redirect/", "code1234") assert.NotEqual(t, nil, err) if session != nil { t.Errorf("expect nill session %#v", session) } }
func TestCheckStatusEtcdNoHealthNoConnect(t *testing.T) { t.Skip("this test isn't working - hangs") var ts *httptest.Server var f func(http.ResponseWriter, *http.Request) f = func(w http.ResponseWriter, r *http.Request) { switch r.URL.String() { case "/v2/members": m1 := []memb{{ ClientURLs: []string{"http://" + r.Host}, ID: "fumble", Name: "newstuff", PeerURLs: []string{"http://" + r.Host}, }} m := &members{Members: m1} b, err := json.Marshal(m) if err != nil { t.Fatal("Marshal failed") } fmt.Fprintf(w, string(b)) return case "/health": ts.Close() return } fmt.Fprintln(w, "hello there etcd user") } ts = httptest.NewServer(http.HandlerFunc(f)) defer ts.Close() cfg := []*Config{{ Name: "SiteCheckTest", Type: "etcd", URL: []string{ts.URL}, Timeout: 20, }} s := &server{cfg: cfg} s.refresh(Wait) failCheck(t, cfg) }
func TestFetchCertDepth(t *testing.T) { var count byte var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { count++ if count > maxChainLen+1 { t.Errorf("count = %d; want at most %d", count, maxChainLen+1) w.WriteHeader(http.StatusInternalServerError) } w.Header().Set("link", fmt.Sprintf("<%s>;rel=up", ts.URL)) w.Write([]byte{count}) })) defer ts.Close() _, err := (&Client{}).FetchCert(context.Background(), ts.URL, true) if err == nil { t.Errorf("err is nil") } }
func TestGoogleProviderGetEmailAddressEmailMissing(t *testing.T) { p := newGoogleProvider() body, err := json.Marshal(redeemResponse{ AccessToken: "a1234", IdToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"not_email": "missing"}`)), }) assert.Equal(t, nil, err) var server *httptest.Server p.RedeemUrl, server = newRedeemServer(body) defer server.Close() session, err := p.Redeem("http://redirect/", "code1234") assert.NotEqual(t, nil, err) if session != nil { t.Errorf("expect nill session %#v", session) } }
func TestClientRedirectUseResponse(t *testing.T) { setParallel(t) defer afterTest(t) const body = "Hello, world." var ts *httptest.Server ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) { if strings.Contains(r.URL.Path, "/other") { io.WriteString(w, "wrong body") } else { w.Header().Set("Location", ts.URL+"/other") w.WriteHeader(StatusFound) io.WriteString(w, body) } })) defer ts.Close() tr := &Transport{} defer tr.CloseIdleConnections() c := &Client{ Transport: tr, CheckRedirect: func(req *Request, via []*Request) error { if req.Response == nil { t.Error("expected non-nil Request.Response") } return ErrUseLastResponse }, } res, err := c.Get(ts.URL) if err != nil { t.Fatal(err) } if res.StatusCode != StatusFound { t.Errorf("status = %d; want %d", res.StatusCode, StatusFound) } defer res.Body.Close() slurp, err := ioutil.ReadAll(res.Body) if err != nil { t.Fatal(err) } if string(slurp) != body { t.Errorf("body = %q; want %q", slurp, body) } }
// ExpectS3Artifact will setup queue to expect an S3 artifact with given // name to be created for taskID and runID using m and returns // a channel which will receive the artifact. func (m *MockQueue) ExpectS3Artifact(taskID string, runID int, name string) <-chan []byte { // make channel size 100 so we don't have to handle synchronously c := make(chan []byte, 100) var s *httptest.Server s = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { d, err := ioutil.ReadAll(r.Body) if err != nil { close(c) w.WriteHeader(500) return } if r.Header.Get("Content-Encoding") == "gzip" { reader, err := gzip.NewReader(bytes.NewReader(d)) if err != nil { close(c) w.WriteHeader(500) return } d, err = ioutil.ReadAll(reader) if err != nil { close(c) w.WriteHeader(500) return } } w.WriteHeader(200) c <- d go s.Close() // Close when all requests are done (don't block the request) })) data, _ := json.Marshal(queue.S3ArtifactResponse{ StorageType: "s3", PutURL: s.URL, ContentType: "application/octet", Expires: tcclient.Time(time.Now().Add(30 * time.Minute)), }) result := queue.PostArtifactResponse(data) m.On( "CreateArtifact", taskID, fmt.Sprintf("%d", runID), name, PostS3ArtifactRequest, ).Return(&result, nil) return c }
func TestGoogleProviderGetEmailAddress(t *testing.T) { p := newGoogleProvider() body, err := json.Marshal(redeemResponse{ AccessToken: "a1234", ExpiresIn: 10, RefreshToken: "refresh12345", IdToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"email": "*****@*****.**", "email_verified":true}`)), }) assert.Equal(t, nil, err) var server *httptest.Server p.RedeemUrl, server = newRedeemServer(body) defer server.Close() session, err := p.Redeem("http://redirect/", "code1234") assert.Equal(t, nil, err) assert.NotEqual(t, session, nil) assert.Equal(t, "*****@*****.**", session.Email) assert.Equal(t, "a1234", session.AccessToken) assert.Equal(t, "refresh12345", session.RefreshToken) }
func TestShowJob(t *testing.T) { var err error var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) w.Write([]byte(`{ "id": "jobId" }`)) })) defer ts.Close() JOBS_ADDRESS = ts.URL job, err := ShowJob("jobId") if err != nil { t.Error(err) } if job.Id != "jobId" { t.Error("job.Id != 'jobId'") } }
func TestFetchCert(t *testing.T) { var count byte var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { count++ if count < 3 { up := fmt.Sprintf("<%s>;rel=up", ts.URL) w.Header().Set("link", up) } w.Write([]byte{count}) })) defer ts.Close() res, err := (&Client{}).FetchCert(context.Background(), ts.URL, true) if err != nil { t.Fatalf("FetchCert: %v", err) } cert := [][]byte{{1}, {2}, {3}} if !reflect.DeepEqual(res, cert) { t.Errorf("res = %v; want %v", res, cert) } }
func TestRedirectCookiesJar(t *testing.T) { setParallel(t) defer afterTest(t) var ts *httptest.Server ts = httptest.NewServer(echoCookiesRedirectHandler) defer ts.Close() tr := &Transport{} defer tr.CloseIdleConnections() c := &Client{ Transport: tr, Jar: new(TestJar), } u, _ := url.Parse(ts.URL) c.Jar.SetCookies(u, []*Cookie{expectedCookies[0]}) resp, err := c.Get(ts.URL) if err != nil { t.Fatalf("Get: %v", err) } resp.Body.Close() matchReturnedCookies(t, expectedCookies, resp.Cookies()) }
func TestListJobs(t *testing.T) { var err error var ts *httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) w.Write([]byte(`[ { "id": "job1" }, { "id": "job2" } ]`)) })) defer ts.Close() JOBS_ADDRESS = ts.URL jobs, err := ListJobs() if err != nil { t.Error(err) } if len(jobs) != 2 { t.Error("len(jobs) != 2") } }
func TestProvider_Failure(t *testing.T) { var ( h *httptest.Server g *httptest.Server ) logs := "Hello" h = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Logf("%s %s", r.Method, r.URL.Path) switch r.URL.Path { case "/apps/acme-inc/builds": fmt.Fprintf(w, `{"id": "1234", "output_stream_url": "%s/stream"}`, h.URL) case "/stream": fmt.Fprintf(w, logs) case "/apps/acme-inc/builds/1234/result": fmt.Fprintf(w, `{"build":{"status":"failed"}}`) } })) g = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Location", "http://github.com/archive") w.WriteHeader(302) })) defer h.Close() defer g.Close() p := NewProvider("", "") p.heroku.URL = h.URL p.github.BaseURL = mustURLParse(g.URL) d := &tugboat.Deployment{ Repo: "ejholmes/acme-inc", Environment: "production", } w := new(bytes.Buffer) if err := p.Deploy(context.Background(), d, w); err != tugboat.ErrFailed { t.Fatalf("Err => %v; want %v", err, tugboat.ErrFailed) } }
func GetTestServerMessage(p *Proxy, ts *httptest.Server, path string) (string, error) { echoProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { p.ServeHTTP(w, r) })) // *httptest.Server is passed so it can be `defer`red properly defer ts.Close() defer echoProxy.Close() res, err := http.Get(echoProxy.URL + path) if err != nil { return "", fmt.Errorf("Unable to GET: %v", err) } greeting, err := ioutil.ReadAll(res.Body) res.Body.Close() if err != nil { return "", fmt.Errorf("Unable to read body: %v", err) } return fmt.Sprintf("%s", greeting), nil }