import (
"encoding/json"
"fmt"
+ "net"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"git.curoverse.com/arvados.git/sdk/go/arvadosclient"
+ "git.curoverse.com/arvados.git/sdk/go/arvadostest"
"git.curoverse.com/arvados.git/sdk/go/blockdigest"
"git.curoverse.com/arvados.git/sdk/go/keepclient"
defer server.Close()
tl := map[string]TrashList{
- server.URL: TrashList{TrashRequest{"000000000000000000000000deadbeef", 99}}}
+ server.URL: {TrashRequest{"000000000000000000000000deadbeef", 99}}}
arv := arvadosclient.ArvadosClient{ApiToken: "abc123"}
kc := keepclient.KeepClient{Arvados: &arv, Client: &http.Client{}}
map[string]string{"xxxx": server.URL},
map[string]string{})
- err := SendTrashLists(&kc, tl)
+ err := SendTrashLists(nil, &kc, tl, false)
c.Check(err, IsNil)
func sendTrashListError(c *C, server *httptest.Server) {
tl := map[string]TrashList{
- server.URL: TrashList{TrashRequest{"000000000000000000000000deadbeef", 99}}}
+ server.URL: {TrashRequest{"000000000000000000000000deadbeef", 99}}}
arv := arvadosclient.ArvadosClient{ApiToken: "abc123"}
kc := keepclient.KeepClient{Arvados: &arv, Client: &http.Client{}}
map[string]string{"xxxx": server.URL},
map[string]string{})
- err := SendTrashLists(&kc, tl)
+ err := SendTrashLists(nil, &kc, tl, false)
c.Check(err, NotNil)
c.Check(err[0], NotNil)
sendTrashListError(c, httptest.NewUnstartedServer(&TestHandler{}))
}
-type StatusAndBody struct {
- respStatus int
- responseBody string
-}
-
-type APIStub struct {
- data map[string]StatusAndBody
-}
-
-func (stub *APIStub) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
- if req.URL.Path == "/redirect-loop" {
- http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
- return
- }
-
- pathResponse := stub.data[req.URL.Path]
- if pathResponse.responseBody != "" {
- if pathResponse.respStatus == -1 {
- http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
- } else {
- resp.WriteHeader(pathResponse.respStatus)
- resp.Write([]byte(pathResponse.responseBody))
- }
- } else {
- resp.WriteHeader(500)
- resp.Write([]byte(``))
- }
-}
-
-type KeepServerStub struct {
- data map[string]StatusAndBody
-}
-
-func (stub *KeepServerStub) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
- if req.URL.Path == "/redirect-loop" {
- http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
- return
- }
-
- pathResponse := stub.data[req.URL.Path]
- if pathResponse.responseBody != "" {
- if pathResponse.respStatus == -1 {
- http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
- } else {
- resp.WriteHeader(pathResponse.respStatus)
- resp.Write([]byte(pathResponse.responseBody))
- }
- } else {
- resp.WriteHeader(500)
- resp.Write([]byte(``))
- }
-}
-
type APITestData struct {
numServers int
serverType string
}
func (s *KeepSuite) TestGetKeepServers_UnsupportedServiceType(c *C) {
- testGetKeepServersFromAPI(c, APITestData{1, "notadisk", 200})
+ testGetKeepServersFromAPI(c, APITestData{1, "notadisk", 200}, "Found no keepservices with the service type disk")
}
func (s *KeepSuite) TestGetKeepServers_ReceivedTooFewServers(c *C) {
- testGetKeepServersFromAPI(c, APITestData{2, "disk", 200})
+ testGetKeepServersFromAPI(c, APITestData{2, "disk", 200}, "Did not receive all available keep servers")
}
func (s *KeepSuite) TestGetKeepServers_ServerError(c *C) {
- testGetKeepServersFromAPI(c, APITestData{-1, "disk", -1})
+ testGetKeepServersFromAPI(c, APITestData{-1, "disk", -1}, "arvados API server error")
}
-func testGetKeepServersFromAPI(c *C, testData APITestData) {
+func testGetKeepServersFromAPI(c *C, testData APITestData, expectedError string) {
keepServers := ServiceList{
ItemsAvailable: testData.numServers,
KeepServers: []ServerAddress{{
}
ksJSON, _ := json.Marshal(keepServers)
- apiData := make(map[string]StatusAndBody)
- apiData["/arvados/v1/keep_services"] = StatusAndBody{testData.statusCode, string(ksJSON)}
- apiStub := APIStub{apiData}
+ apiStubResponses := make(map[string]arvadostest.StubResponse)
+ apiStubResponses["/arvados/v1/keep_services"] = arvadostest.StubResponse{testData.statusCode, string(ksJSON)}
+ apiStub := arvadostest.ServerStub{apiStubResponses}
api := httptest.NewServer(&apiStub)
defer api.Close()
}
_, err := GetKeepServersAndSummarize(params)
- if testData.numServers > 1 {
- c.Assert(err, ErrorMatches, ".*Did not receive all available keep servers.*")
- } else if testData.serverType != "disk" {
- c.Assert(err, ErrorMatches, ".*Unsupported service type.*")
- }
+ c.Assert(err, NotNil)
+ c.Assert(err, ErrorMatches, fmt.Sprintf(".*%s.*", expectedError))
}
type KeepServerTestData struct {
func (s *KeepSuite) TestGetKeepServers_ErrorGettingKeepServerStatus(c *C) {
testGetKeepServersAndSummarize(c, KeepServerTestData{500, 200, "ok",
- "500 Internal Server Error"})
+ ".*http://.* 500 Internal Server Error"})
}
func (s *KeepSuite) TestGetKeepServers_GettingIndex(c *C) {
testGetKeepServersAndSummarize(c, KeepServerTestData{200, -1, "notok",
- "redirect-loop"})
+ ".*redirect-loop.*"})
}
func (s *KeepSuite) TestGetKeepServers_ErrorReadServerResponse(c *C) {
testGetKeepServersAndSummarize(c, KeepServerTestData{200, 500, "notok",
- "500 Internal Server Error"})
+ ".*http://.* 500 Internal Server Error"})
}
func (s *KeepSuite) TestGetKeepServers_ReadServerResponseTuncatedAtLineOne(c *C) {
testGetKeepServersAndSummarize(c, KeepServerTestData{200, 200,
- "notterminatedwithnewline", "truncated at line 1"})
+ "notterminatedwithnewline", "Index from http://.* truncated at line 1"})
}
func (s *KeepSuite) TestGetKeepServers_InvalidBlockLocatorPattern(c *C) {
testGetKeepServersAndSummarize(c, KeepServerTestData{200, 200, "testing\n",
- "Error parsing BlockInfo from index line"})
+ "Error parsing BlockInfo from index line.*"})
}
func (s *KeepSuite) TestGetKeepServers_ReadServerResponseEmpty(c *C) {
}
func testGetKeepServersAndSummarize(c *C, testData KeepServerTestData) {
- ksData := make(map[string]StatusAndBody)
- ksData["/status.json"] = StatusAndBody{testData.statusStatusCode, string(`{}`)}
- ksData["/index"] = StatusAndBody{testData.indexStatusCode, testData.indexResponseBody}
- ksStub := KeepServerStub{ksData}
+ ksStubResponses := make(map[string]arvadostest.StubResponse)
+ ksStubResponses["/status.json"] = arvadostest.StubResponse{testData.statusStatusCode, string(`{}`)}
+ ksStubResponses["/index"] = arvadostest.StubResponse{testData.indexStatusCode, testData.indexResponseBody}
+ ksStub := arvadostest.ServerStub{ksStubResponses}
ks := httptest.NewServer(&ksStub)
defer ks.Close()
ksURL, err := url.Parse(ks.URL)
c.Check(err, IsNil)
- ksURLParts := strings.Split(ksURL.Host, ":")
- ksPort, err := strconv.Atoi(ksURLParts[1])
+ ksHost, port, err := net.SplitHostPort(ksURL.Host)
+ ksPort, err := strconv.Atoi(port)
c.Check(err, IsNil)
servers_list := ServiceList{
ItemsAvailable: 1,
KeepServers: []ServerAddress{{
SSL: false,
- Host: strings.Split(ksURL.Host, ":")[0],
+ Host: ksHost,
Port: ksPort,
UUID: "abcdefg",
ServiceType: "disk",
}},
}
ksJSON, _ := json.Marshal(servers_list)
- apiData := make(map[string]StatusAndBody)
- apiData["/arvados/v1/keep_services"] = StatusAndBody{200, string(ksJSON)}
- apiStub := APIStub{apiData}
+ apiStubResponses := make(map[string]arvadostest.StubResponse)
+ apiStubResponses["/arvados/v1/keep_services"] = arvadostest.StubResponse{200, string(ksJSON)}
+ apiStub := arvadostest.ServerStub{apiStubResponses}
api := httptest.NewServer(&apiStub)
defer api.Close()
}
}
} else {
- if testData.expectedError == "Error parsing BlockInfo from index line" {
- // In this case ErrorMatches does not work because the error message contains regexp match characters
- strings.Contains(err.Error(), testData.expectedError)
- } else {
- c.Assert(err, ErrorMatches, fmt.Sprintf(".*%s.*", testData.expectedError))
- }
+ c.Assert(err, ErrorMatches, testData.expectedError)
}
}
projects / arvados.git / blobdiff