func listStoriesHandler(trackerToken string) http.HandlerFunc {
return ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/services/v5/projects/1234/stories"),
ghttp.VerifyHeaderKV("X-TrackerToken", trackerToken),
ghttp.RespondWith(http.StatusOK, Fixture("stories.json")),
)
}
func deliverStoryHandler(token string, projectId string, storyId int) http.HandlerFunc {
body := `{"current_state":"delivered"}`
return ghttp.CombineHandlers(
ghttp.VerifyRequest(
"PUT",
fmt.Sprintf("/services/v5/projects/%s/stories/%d", projectId, storyId),
), ghttp.VerifyHeaderKV("X-TrackerToken", token),
ghttp.VerifyJSON(body),
)
}
func deliverStoryCommentHandler(token string, projectId string, storyId int, comment string) http.HandlerFunc {
body := fmt.Sprintf(`{"text":"%s"}`, comment)
return ghttp.CombineHandlers(
ghttp.VerifyRequest(
"POST",
fmt.Sprintf("/services/v5/projects/%s/stories/%d/comments", projectId, storyId),
), ghttp.VerifyHeaderKV("X-TrackerToken", token),
ghttp.VerifyJSON(body),
)
}
server.Close()
})
Context("with an OAuth Token", func() {
BeforeEach(func() {
source = Source{
User: "******",
Repository: "concourse",
AccessToken: "abc123",
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/repos/concourse/concourse/releases"),
ghttp.RespondWith(200, "[]"),
ghttp.VerifyHeaderKV("Authorization", "Bearer abc123"),
),
)
})
It("sends one", func() {
_, err := client.ListReleases()
Ω(err).ShouldNot(HaveOccurred())
})
})
Context("without an OAuth Token", func() {
BeforeEach(func() {
source = Source{
User: "******",
Repository: "concourse",
Eventually(sess.Out).Should(gbytes.Say("target saved"))
err = stdin.Close()
Expect(err).NotTo(HaveOccurred())
<-sess.Exited
Expect(sess.ExitCode()).To(Equal(0))
})
Describe("running other commands", func() {
BeforeEach(func() {
atcServer.AppendHandlers(
infoHandler(),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/api/v1/pipelines"),
ghttp.VerifyHeaderKV("Authorization", "Bearer some-entered-token"),
ghttp.RespondWithJSONEncoded(200, []atc.Pipeline{
{Name: "pipeline-1"},
}),
),
)
})
It("uses the saved token", func() {
otherCmd := exec.Command(flyPath, "-t", "some-target", "pipelines")
sess, err := gexec.Start(otherCmd, GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
<-sess.Exited
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Releases", func() {
var (
req resource.ReleaseRequester
server *ghttp.Server
testRelease *resource.Release
testProductFiles *resource.ProductFiles
pivotalProductFile resource.ProductFile
licenseProductFile resource.ProductFile
eulaMessage resource.EulaMessage
)
verifyHeaders := ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Authorization", "Token token"),
ghttp.VerifyHeaderKV("Content-Type", "application/json"),
ghttp.VerifyHeaderKV("Accept", "application/json"),
)
BeforeEach(func() {
server = ghttp.NewServer()
req = resource.NewRequester(server.URL(), "token")
testRelease = &resource.Release{
Id: 123,
Version: "1.1",
Links: resource.Links{
"product_files": resource.Link{Url: server.URL() + "/api/v2/products/my-prod/releases/123/product_files"},
},
}
})
Context("when configuring with templated keys succeeds", func() {
JustBeforeEach(func() {
var err error
payload, err = yaml.Marshal(config)
Ω(err).ShouldNot(HaveOccurred())
})
BeforeEach(func() {
path, err := atc.Routes.CreatePathForRoute(atc.SaveConfig, rata.Params{"pipeline_name": "awesome-pipeline"})
Ω(err).ShouldNot(HaveOccurred())
atcServer.RouteToHandler("PUT", path,
ghttp.CombineHandlers(
ghttp.VerifyHeaderKV(atc.ConfigVersionHeader, "42"),
func(w http.ResponseWriter, r *http.Request) {
bodyConfig, state := getConfigAndPausedState(r)
Ω(state).Should(BeNil())
receivedConfig := atc.Config{}
err = yaml.Unmarshal(bodyConfig, &receivedConfig)
Ω(err).ShouldNot(HaveOccurred())
Ω(receivedConfig).Should(Equal(config))
},
),
)
})
It("parses the config file and sends it to the ATC", func() {
var fakeUAA *ghttp.Server
BeforeEach(func() {
authRepo.RefreshToken = "bearer client-bearer-token"
configRepo.SetSSLDisabled(true)
configRepo.SetSSHOAuthClient("ssh-oauth-client-id")
fakeUAA = ghttp.NewTLSServer()
configRepo.SetUaaEndpoint(fakeUAA.URL())
fakeUAA.RouteToHandler("GET", "/oauth/authorize", ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/oauth/authorize"),
ghttp.VerifyFormKV("response_type", "code"),
ghttp.VerifyFormKV("client_id", "ssh-oauth-client-id"),
ghttp.VerifyFormKV("grant_type", "authorization_code"),
ghttp.VerifyHeaderKV("authorization", "bearer client-bearer-token"),
ghttp.RespondWith(http.StatusFound, "", http.Header{
"Location": []string{"https://uaa.example.com/login?code=abc123"},
}),
))
})
It("gets the access code from the token endpoint", func() {
runCommand()
Ω(authRepo.RefreshTokenCalled).To(BeTrue())
Ω(fakeUAA.ReceivedRequests()).To(HaveLen(1))
Ω(ui.Outputs).To(ContainSubstrings(
[]string{"abc123"},
))
})
respBody, ok := response.Result.(io.ReadCloser)
Expect(ok).To(BeTrue())
Expect(respBody.Close()).NotTo(HaveOccurred())
})
})
Context("Request Headers", func() {
BeforeEach(func() {
atcServer = ghttp.NewServer()
connection = NewConnection(atcServer.URL(), nil)
atcServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/api/v1/builds/foo"),
ghttp.VerifyHeaderKV("Accept-Encoding", "application/banana"),
ghttp.VerifyHeaderKV("foo", "bar", "baz"),
ghttp.RespondWithJSONEncoded(http.StatusOK, atc.Build{}),
),
)
})
It("sets the header and it's values on the request", func() {
err := connection.Send(Request{
RequestName: atc.GetBuild,
Params: rata.Params{"build_id": "foo"},
Header: http.Header{
"Accept-Encoding": {"application/banana"},
"Foo": {"bar", "baz"},
},
}, &Response{
BeforeEach(func() {
server = ghttp.NewServer()
f = &Flipkart{
AffiliateId: "fk-id",
AffliateToken: "fk-secret",
Host: server.URL()[7:],
Scheme: "http",
}
})
Context("TopOffers", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/affiliate/offers/v1/top/json"),
ghttp.VerifyHeaderKV("Fk-Affiliate-Id", "fk-id"),
ghttp.VerifyHeaderKV("Fk-Affiliate-Token", "fk-secret"),
ghttp.RespondWith(200, topResult),
))
})
It("retrieves the top offers", func() {
resp, err := f.TopOffers()
Expect(err).NotTo(HaveOccurred())
Expect(len(resp.TopOffersList)).To(Equal(14))
})
})
Context("DOTDOffers", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
UserAgent: userAgent,
}
client = pivnet.NewClient(newClientConfig, fakeLogger)
})
AfterEach(func() {
server.Close()
})
It("has authenticated headers for each request", func() {
response := fmt.Sprintf(`{"releases": [{"version": "1234"}]}`)
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", apiPrefix+"/products/my-product-id/releases"),
ghttp.VerifyHeaderKV("Authorization", fmt.Sprintf("Token %s", token)),
ghttp.RespondWith(http.StatusOK, response),
),
)
_, err := client.ProductVersions("my-product-id")
Expect(err).NotTo(HaveOccurred())
})
It("sets custom user agent", func() {
response := fmt.Sprintf(`{"releases": [{"version": "1234"}]}`)
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", apiPrefix+"/products/my-product-id/releases"),
ghttp.VerifyHeaderKV("Authorization", fmt.Sprintf("Token %s", token)),
"github.com/onsi/gomega/ghttp"
)
var _ = Describe("Releases", func() {
var (
req resource.ReleaseRequester
server *ghttp.Server
testRelease *resource.Release
testProductFiles *resource.ProductFiles
pivotalProductFile resource.ProductFile
licenseProductFile resource.ProductFile
eulaMessage resource.EulaMessage
)
verifyHeaders := ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Authorization", "Token token"),
ghttp.VerifyHeaderKV("Content-Type", "application/json"),
ghttp.VerifyHeaderKV("Accept", "application/json"),
ghttp.VerifyHeaderKV("User-Agent", fmt.Sprintf("gopivnet/%s", resource.Version)),
)
BeforeEach(func() {
server = ghttp.NewServer()
req = resource.NewRequester(server.URL(), "token")
testRelease = &resource.Release{
Id: 123,
Version: "1.1",
Links: resource.Links{
"product_files": resource.Link{Url: server.URL() + "/api/v2/products/my-prod/releases/123/product_files"},
},
)
testServer.AppendHandlers(handler)
testServer.AllowUnhandledRequests = true
bodyChan = make(chan []byte, 3)
testS3Server = ghttp.NewServer()
comparisonFile, err := ioutil.TempFile("", "comparison.csv")
Expect(err).ToNot(HaveOccurred())
comparisonFile.WriteString(comparisonCSV)
comparisonFilePath = comparisonFile.Name()
bodyTestHandler = ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("X-Amz-Acl", "public-read"),
func(rw http.ResponseWriter, req *http.Request) {
defer GinkgoRecover()
defer req.Body.Close()
bodyBytes, err := ioutil.ReadAll(req.Body)
Expect(err).ToNot(HaveOccurred())
bodyChan <- bodyBytes
},
ghttp.RespondWith(http.StatusOK, nil),
)
testS3Server.AppendHandlers(
bodyTestHandler,
ghttp.CombineHandlers(
ghttp.VerifyContentType("image/png"),
bodyTestHandler,
),
It("Handles a very large request", func() {
// init and fill a 12MB buffer
reqSize := 12 * 1024 * 1024 // 12MB
reqSizeStr := strconv.Itoa(reqSize)
reqBody := make([]byte, reqSize)
for i := range reqBody {
reqBody[i] = byte(i % 256)
}
wstuncli = startClient(wstunToken, wstunHost, proxyUrl, server)
waitConnected(wstuncli)
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/large-request"),
ghttp.VerifyHeaderKV("Content-Length", reqSizeStr),
ghttp.RespondWith(200, `WORLD`,
http.Header{"Content-Type": []string{"text/world"}}),
),
)
resp, err := http.Post(wstunUrl+"/_token/"+wstunToken+"/large-request",
"text/binary", bytes.NewReader(reqBody))
Ω(err).ShouldNot(HaveOccurred())
respBody, err := ioutil.ReadAll(resp.Body)
Ω(err).ShouldNot(HaveOccurred())
Ω(string(respBody)).Should(Equal("WORLD"))
Ω(resp.Header.Get("Content-Type")).Should(Equal("text/world"))
Ω(resp.StatusCode).Should(Equal(200))
})
var (
httpStatusCode int
fakeServer *ghttp.Server
httpBody []byte
tmpFile *os.File
fakeServerURL, sanitizedURL string
)
BeforeEach(func() {
httpStatusCode = http.StatusCreated
fakeServer = ghttp.NewServer()
fakeServer.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("PUT", "/blobs/path"),
ghttp.RespondWithPtr(&httpStatusCode, nil),
ghttp.VerifyBasicAuth("user", "pass"),
ghttp.VerifyHeaderKV("Content-Length", "18"),
func(_ http.ResponseWriter, request *http.Request) {
var err error
httpBody, err = ioutil.ReadAll(request.Body)
Expect(err).NotTo(HaveOccurred())
},
))
fakeServerURL = fmt.Sprintf("http://%s:%s@%s%s", "user", "pass", fakeServer.Addr(), "/blobs/path")
sanitizedURL = fmt.Sprintf("http://%s%s", fakeServer.Addr(), "/blobs/path")
var err error
tmpFile, err = ioutil.TempFile(os.TempDir(), "fileToUpload")
Expect(err).NotTo(HaveOccurred())
tmpFile.Write([]byte("some-file-contents"))
Data: []byte("hello"),
}.Write(w)
flusher.Flush()
Event{
ID: "2",
Data: []byte("hello again"),
}.Write(w)
flusher.Flush()
<-closeNotify
},
ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Last-Event-ID", "2"),
func(w http.ResponseWriter, r *http.Request) {
flusher := w.(http.Flusher)
w.Header().Add("Content-Type", "text/event-stream; charset=utf-8")
w.Header().Add("Cache-Control", "no-cache, no-store, must-revalidate")
w.Header().Add("Connection", "keep-alive")
w.WriteHeader(http.StatusOK)
flusher.Flush()
Event{
ID: "3",
Data: []byte("welcome back"),
}.Write(w)
<D:resourcetype>
<D:collection/>
</D:resourcetype>
</D:prop>
<D:status>HTTP/1.1 200 OK</D:status>
</D:propstat>
</D:response>
</D:multistatus>
`
responseBodyA = strings.Replace(responseBodyA, "http://192.168.11.11:8444", fakeServer.URL(), -1)
responseBodyB = strings.Replace(responseBodyB, "http://192.168.11.11:8444", fakeServer.URL(), -1)
responseBodyC = strings.Replace(responseBodyC, "http://192.168.11.11:8444", fakeServer.URL(), -1)
fakeServer.RouteToHandler("PROPFIND", "/blobs", ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Depth", "1"),
ghttp.VerifyBasicAuth("user", "pass"),
ghttp.RespondWith(207, responseBodyRoot, http.Header{"Content-Type": []string{"application/xml"}}),
))
fakeServer.RouteToHandler("PROPFIND", "/blobs/a", ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Depth", "1"),
ghttp.VerifyBasicAuth("user", "pass"),
ghttp.RespondWith(207, responseBodyA, http.Header{"Content-Type": []string{"application/xml"}}),
))
fakeServer.RouteToHandler("PROPFIND", "/blobs/b", ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Depth", "1"),
ghttp.VerifyBasicAuth("user", "pass"),
ghttp.RespondWith(207, responseBodyB, http.Header{"Content-Type": []string{"application/xml"}}),
))
defer server.Close()
// construct list of verifiers
url := regexp.MustCompile(`https?://[^/]+(/[^?]+)\??(.*)`).
FindStringSubmatch(testCase.RR.URI)
//fmt.Fprintf(os.Stderr, "URL: %#v\n", url)
handlers := []http.HandlerFunc{
ghttp.VerifyRequest(testCase.RR.Verb, url[1], url[2]),
}
if len(testCase.RR.ReqBody) > 0 {
handlers = append(handlers,
ghttp.VerifyJSON(testCase.RR.ReqBody))
}
for k := range testCase.RR.ReqHeader {
handlers = append(handlers,
ghttp.VerifyHeaderKV(k, testCase.RR.ReqHeader.Get(k)))
}
respHeader := make(http.Header)
for k, v := range testCase.RR.RespHeader {
respHeader[k] = v
}
handlers = append(handlers,
ghttp.RespondWith(testCase.RR.Status, testCase.RR.RespBody,
respHeader))
server.AppendHandlers(ghttp.CombineHandlers(handlers...))
os.Args = append([]string{
"rsc", "--noAuth", "--dump", "debug",
"--host", strings.TrimPrefix(server.URL(), "http://")},
testCase.CmdArgs...)
//fmt.Fprintf(os.Stderr, "testing \"%s\"\n", strings.Join(os.Args, `" "`))
Mask: net.CIDRMask(24, 32),
},
Gateway: net.ParseIP("192.168.1.1"),
Routes: []types.Route{{
Dst: net.IPNet{
IP: net.ParseIP("192.168.0.0"),
Mask: net.CIDRMask(16, 32),
},
GW: net.ParseIP("192.168.1.1"),
}},
},
}
statusCode := http.StatusCreated
server.RouteToHandler("POST", "/cni/add", ghttp.CombineHandlers(
ghttp.VerifyHeaderKV("Content-Type", "application/json"),
ghttp.RespondWithJSONEncodedPtr(&statusCode, &ipamResult),
))
})
AfterEach(func() {
server.Close()
})
Describe("ADD", func() {
It("returns IPAM data", func() {
var err error
var cmd *exec.Cmd
cmd, err = buildCNICmdLight("ADD", netConfig, containerNSPath, containerID)
Expect(err).NotTo(HaveOccurred())
session, err = gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
token string
)
BeforeEach(func() {
token = "1234-abcd"
})
Context("Success", func() {
It("follows redirects", func() {
header := http.Header{}
header.Add("Location", apiAddress+"/some-redirect-link")
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/the-first-post", ""),
ghttp.VerifyHeaderKV("Authorization", fmt.Sprintf("Token %s", token)),
ghttp.RespondWith(http.StatusFound, nil, header),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/some-redirect-link"),
ghttp.RespondWith(http.StatusOK, make([]byte, 10, 14)),
),
)
fileNames := map[string]string{
"the-first-post": apiAddress + "/the-first-post",
}
err := downloader.Download(dir, fileNames, token)
Expect(err).NotTo(HaveOccurred())
})
