fakeserver.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/modules/"),
ghttp.RespondWithJSONEncodedPtr(&statusCode, &module),
))
err := dataplane.Init(fakeserver.URL())
Expect(err).NotTo(HaveOccurred())
Expect(dataplane.Id()).To(Equal("some-module-id"))
})
It("Adds a policy to the server", func() {
entry = models.TableEntry{
Key: fmt.Sprintf("{ %s %s %s %s %s [ 0 0 0 ]}", "200", "200", "0", "0", "20"),
Value: "0",
}
fakeserver.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/modules/"+dataplane.Id()+"/tables/rules/entries/"),
ghttp.VerifyJSONRepresenting(&entry),
ghttp.RespondWithJSONEncodedPtr(&statusCode, &entry),
))
err := dataplane.AddPolicy("200", "", "200", "", "20", "allow")
Expect(err).NotTo(HaveOccurred())
})
Context("when adding a policy to the server fails", func() {
BeforeEach(func() {
statusCode = http.StatusInternalServerError
fakeserver.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/modules/"+dataplane.Id()+"/tables/rules/entries/"),
ghttp.RespondWithJSONEncodedPtr(&statusCode, models.TableEntry{}),
))
})
It("Returns an error", func() {
err := dataplane.AddPolicy("200", "", "200", "", "20", "allow")
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.RespondWithJSONEncoded(http.StatusOK, originalTask),
),
)
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PATCH", "/tasks/1234"),
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.VerifyJSONRepresenting(expectedTaskUpdateConfig),
ghttp.RespondWithJSONEncoded(http.StatusOK, expectedTask),
),
)
})
Context("when recurrenceType is not provided", func() {
BeforeEach(func() {
task.RecurrenceType = ""
})
It("does not allow recurrenceCount to be non-zero", func() {
task.RecurrenceCount = 1
_, err := client.UpdateTask(task)
Expect(err).To(HaveOccurred())
})
})
})
Context("DeleteRoutes", func() {
var err error
JustBeforeEach(func() {
err = client.DeleteRoutes([]db.Route{route1, route2})
})
Context("when the server returns a valid response", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("DELETE", "/v1/routes"),
ghttp.VerifyJSONRepresenting([]db.Route{route1, route2}),
),
)
})
It("sends a Delete request to the server", func() {
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
It("does not receive an error", func() {
Expect(err).NotTo(HaveOccurred())
})
It("logs the request and response", func() {
expectedBody, _ := json.Marshal([]db.Route{route1, route2})
},
}
expectedTeam = atc.Team{
ID: 1,
Name: "team venture",
}
team = client.Team("team venture")
})
Context("when passed a properly constructed team", func() {
BeforeEach(func() {
atcServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PUT", expectedURL),
ghttp.VerifyJSONRepresenting(desiredTeam),
ghttp.RespondWithJSONEncoded(http.StatusCreated, expectedTeam),
),
)
})
It("returns back the team", func() {
team, _, _, err := team.CreateOrUpdate(desiredTeam)
Expect(err).NotTo(HaveOccurred())
Expect(team).To(Equal(expectedTeam))
})
})
Context("when passed a team that doesn't exist", func() {
BeforeEach(func() {
atcServer.AppendHandlers(
BeforeEach(func() {
ranB = false
parallelNode, parallelTotal = 1, 3
})
Context("as the first node, it runs A", func() {
var expectedState types.RemoteBeforeSuiteData
BeforeEach(func() {
parallelNode, parallelTotal = 1, 3
})
JustBeforeEach(func() {
server.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/BeforeSuiteState"),
ghttp.VerifyJSONRepresenting(expectedState),
))
outcome = node.Run(parallelNode, parallelTotal, server.URL())
})
Context("when A succeeds", func() {
BeforeEach(func() {
expectedState = types.RemoteBeforeSuiteData{[]byte("my data"), types.RemoteBeforeSuiteStatePassed}
node = newNode(func() []byte {
return []byte("my data")
}, func([]byte) {
ranB = true
})
})
BeforeEach(func() {
expectedCNIPayload = models.CNIAddPayload{
Args: "FOO=BAR;ABC=123",
ContainerNamespace: "/some/namespace/path",
InterfaceName: "interface-name",
ContainerID: "some-container-id",
Network: models.NetworkPayload{
Properties: models.Properties{
AppID: "some-app-id",
},
},
}
server.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/cni/add"),
ghttp.VerifyJSONRepresenting(expectedCNIPayload),
ghttp.VerifyHeaderKV("Content-type", "application/json"),
ghttp.RespondWithJSONEncoded(http.StatusCreated, types.Result{}),
))
})
It("passes it through", func() {
_, err := c.CNIAdd(&skel.CmdArgs{
ContainerID: "some-container-id",
Netns: "/some/namespace/path",
IfName: "interface-name",
Args: "FOO=BAR;ABC=123",
StdinData: []byte(`{
"network": {
"network_id": "",
"properties": {
BeforeEach(func() {
listPosition = wl.Position{
ID: 1234,
}
})
It("performs PATCH requests with correct headers to /list_positions/:id", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PATCH", "/list_positions/1234"),
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.VerifyJSONRepresenting(listPosition),
),
)
client.UpdateListPosition(listPosition)
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
Context("when the request is valid", func() {
It("returns successfully", func() {
expectedListPosition := wl.Position{
ID: listPosition.ID,
}
server.AppendHandlers(
AfterEach(func() {
authServer.Close()
server.Close()
})
It("registers a route to the routing api", func() {
command := buildCommand("register", flags, []string{`[{"route":"zak.com","port":3,"ip":"4"}]`})
server.SetHandler(0,
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/v1/routes"),
ghttp.VerifyJSONRepresenting([]map[string]interface{}{
{
"route": "zak.com",
"port": 3,
"ip": "4",
"ttl": 0,
"log_guid": "",
},
}),
ghttp.RespondWithJSONEncoded(http.StatusOK, nil),
),
)
session := routeRegistrar(command...)
Eventually(session, "2s").Should(Exit(0))
Expect(server.ReceivedRequests()).To(HaveLen(1))
})
It("registers multiple routes to the routing api", func() {
expectedBuild = atc.Build{
ID: 123,
Name: "mybuild",
Status: "succeeded",
JobName: "myjob",
URL: "/builds/123",
APIURL: "/api/v1/builds/123",
}
expectedURL := "/api/v1/builds"
atcServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", expectedURL),
ghttp.VerifyJSONRepresenting(plan),
ghttp.RespondWithJSONEncoded(http.StatusCreated, expectedBuild),
),
)
})
It("takes a plan and creates the build", func() {
build, err := client.CreateBuild(plan)
Expect(err).NotTo(HaveOccurred())
Expect(build).To(Equal(expectedBuild))
})
})
Describe("CreateJobBuild", func() {
var (
pipelineName string
BeforeEach(func() {
list = wl.List{
ID: 1234,
}
})
It("performs PATCH requests with correct headers to /lists/:id", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PATCH", "/lists/1234"),
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.VerifyJSONRepresenting(list),
),
)
client.UpdateList(list)
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
Context("when the request is valid", func() {
It("returns successfully", func() {
expectedList := wl.List{ID: list.ID}
// Marshal and unmarshal to ensure exact object is returned
// - this avoids odd behavior with the time fields
expectedBody, err := json.Marshal(expectedList)
reminder wl.Reminder
)
BeforeEach(func() {
reminder = wl.Reminder{ID: 1234}
})
It("performs GET requests with correct headers to /reminders/:id", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PATCH", "/reminders/1234"),
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.VerifyJSONRepresenting(reminder),
),
)
client.UpdateReminder(reminder)
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
Context("when the request is valid", func() {
It("returns successfully", func() {
expectedReminder := wl.Reminder{ID: 2345}
// Marshal and unmarshal to ensure exact object is returned
// - this avoids odd behavior with the time fields
expectedBody, err := json.Marshal(expectedReminder)
membership = wl.Membership{ID: 1234}
})
It("performs POST requests with correct headers to /memberships/:userID", func() {
expectedMembership := wl.Membership{
ID: membership.ID,
State: "accepted",
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PATCH", "/memberships/1234"),
ghttp.VerifyHeader(http.Header{
"X-Access-Token": []string{dummyAccessToken},
"X-Client-ID": []string{dummyClientID},
}),
ghttp.VerifyJSONRepresenting(expectedMembership),
),
)
client.AcceptMember(membership)
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
Context("when the request is valid", func() {
It("returns successfully", func() {
expectedMembership := wl.Membership{
ID: membership.ID,
}
server.AppendHandlers(
server = ghttp.NewServer()
os.Args = []string{"basic", "-insecure", "-e=dummy", "-p=dummy", "-a=42", "-h=" + server.URL()[7:]}
osStdout = &out
})
AfterEach(func() {
server.Close()
})
It("lists executions", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/api/sessions"),
ghttp.VerifyJSONRepresenting(map[string]interface{}{
"email": "dummy",
"password": "******",
"account_href": "/api/accounts/42",
}),
ghttp.RespondWith(204, ""),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/api/sessions"),
ghttp.RespondWith(200, ""),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/api/clouds"),
ghttp.RespondWith(200, responseBody),
),
)
main()
Ω(out.String()).Should(Equal(output))
ghttp.VerifyRequest("POST", "/api/v1/pipes"),
ghttp.RespondWithJSONEncoded(http.StatusCreated, atc.Pipe{
ID: "some-pipe-id",
}),
),
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/api/v1/pipes"),
ghttp.RespondWithJSONEncoded(http.StatusCreated, atc.Pipe{
ID: "some-other-pipe-id",
}),
),
)
atcServer.RouteToHandler("POST", "/api/v1/builds",
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/api/v1/builds"),
ghttp.VerifyJSONRepresenting(expectedPlan),
func(w http.ResponseWriter, r *http.Request) {
http.SetCookie(w, &http.Cookie{
Name: "Some-Cookie",
Value: "some-cookie-data",
Path: "/",
Expires: time.Now().Add(1 * time.Minute),
})
},
ghttp.RespondWith(201, `{"id":128}`),
),
)
atcServer.RouteToHandler("GET", "/api/v1/builds/128/events",
ghttp.CombineHandlers(
ghttp.VerifyRequest("GET", "/api/v1/builds/128/events"),
func(w http.ResponseWriter, r *http.Request) {
file, _ := ioutil.TempDir(os.TempDir(), "gohan_test")
os.Setenv("GOHAN_CACHE_SCHEMAS", "true")
os.Setenv("GOHAN_CACHE_PATH", file)
opts, _ := NewOptsFromEnv()
gohanClientCLI, err := NewGohanClientCLI(opts)
Expect(gohanClientCLI).To(BeNil())
Expect(err).To(HaveOccurred())
})
})
Describe("Keystone interaction", func() {
Describe("Authentication", func() {
It("Should authenticate successfully", func() {
server.AppendHandlers(ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/v2.0/tokens"),
ghttp.VerifyJSONRepresenting(getAuthRequest()),
ghttp.RespondWithJSONEncoded(200, getAuthResponse(server.URL())),
))
provider, err = getProviderClient()
Expect(err).ToNot(HaveOccurred())
Expect(provider.IdentityBase).To(Equal(server.URL() + "/"))
Expect(provider.IdentityEndpoint).To(Equal(server.URL() + "/v2.0/"))
Expect(provider.TokenID).To(Equal("admin_token"))
})
It("Should show error - OS_AUTH_URL not set", func() {
os.Unsetenv("OS_AUTH_URL")
provider, err = getProviderClient()
Expect(provider).To(BeNil())
Expect(err).To(MatchError("Environment variable OS_AUTH_URL needs to be set."))
})
var testContainer garden.ContainerSpec
BeforeEach(func() {
testContainer = garden.ContainerSpec{
Handle: "Fred",
GraceTime: 1 * time.Second,
RootFSPath: "/stuff",
Env: []string{
"jim",
"jane",
},
}
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/api/containers"),
ghttp.VerifyJSONRepresenting(testContainer),
ghttp.RespondWith(200, `{"handle":"ServerChangedHandle"}`),
),
)
})
It("makes a call out to an external service", func() {
_, err := dotNetBackend.Create(testContainer)
Expect(err).NotTo(HaveOccurred())
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
It("sets the container's handle from the response", func() {
container, err := dotNetBackend.Create(testContainer)
Expect(err).NotTo(HaveOccurred())
Expect(container.Handle()).To(Equal("ServerChangedHandle"))
expectedRequestBody = requestBody{
ProductFile: pivnet.ProductFile{
FileType: "Software",
FileVersion: createProductFileConfig.FileVersion,
Name: createProductFileConfig.Name,
MD5: "not-supported-yet",
AWSObjectKey: createProductFileConfig.AWSObjectKey,
},
}
})
It("creates the release with the minimum required fields", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", apiPrefix+"/products/"+productSlug+"/product_files"),
ghttp.VerifyJSONRepresenting(&expectedRequestBody),
ghttp.RespondWith(http.StatusCreated, validResponse),
),
)
release, err := client.CreateProductFile(createProductFileConfig)
Expect(err).NotTo(HaveOccurred())
Expect(release.ID).To(Equal(1234))
})
})
Context("when the server responds with a non-201 status code", func() {
It("returns an error", func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", apiPrefix+"/products/"+productSlug+"/product_files"),
Context("when streaming succeeds to completion", func() {
BeforeEach(func() {
spec = garden.ProcessSpec{
Path: "lol",
Args: []string{"arg1", "arg2"},
Dir: "/some/dir",
User: "******",
Limits: resourceLimits,
}
stdInContent = make(chan string)
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/containers/foo-handle/processes"),
ghttp.VerifyJSONRepresenting(spec),
func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
conn, br, err := w.(http.Hijacker).Hijack()
Ω(err).ShouldNot(HaveOccurred())
defer conn.Close()
decoder := json.NewDecoder(br)
transport.WriteMessage(conn, map[string]interface{}{
"process_id": 42,
"stream_id": "123",
})
})
})
})
Context("DeleteRoutes", func() {
var err error
JustBeforeEach(func() {
err = client.DeleteRoutes([]models.Route{route1, route2})
})
Context("when the server returns a valid response", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("DELETE", ROUTES_API_URL),
ghttp.VerifyJSONRepresenting([]models.Route{route1, route2}),
),
)
})
It("sends a Delete request to the server", func() {
Expect(server.ReceivedRequests()).Should(HaveLen(1))
})
It("does not receive an error", func() {
Expect(err).NotTo(HaveOccurred())
})
It("logs the request and response", func() {
expectedBody, _ := json.Marshal([]models.Route{route1, route2})