projects / arvados.git / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
8460: Fix copy-paste errors; use html entity instead of literal utf8 bullet.
[arvados.git] / services / datamanager / keep / keep_test.go
diff --git a/services/datamanager/keep/keep_test.go b/services/datamanager/keep/keep_test.go
index 3ca7b8218ae011915daae8d61451fb147ae85f41..ca8797ea6e403a4463cd0de27edaa139ceb5ce2c 100644 (file)
--- a/services/datamanager/keep/keep_test.go
+++ b/services/datamanager/keep/keep_test.go
@@ -12,6 +12,7 @@ import (
        "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"
 
@@ -42,15 +43,15 @@ func (s *KeepSuite) TestSendTrashLists(c *C) {
        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{}}
+       arv := &arvadosclient.ArvadosClient{ApiToken: "abc123"}
+       kc := keepclient.KeepClient{Arvados: arv, Client: &http.Client{}}
        kc.SetServiceRoots(map[string]string{"xxxx": server.URL},
                map[string]string{"xxxx": server.URL},
                map[string]string{})
 
-       err := SendTrashLists(&kc, tl)
+       err := SendTrashLists(nil, &kc, tl, false)
 
        c.Check(err, IsNil)
 
@@ -69,15 +70,15 @@ func (tse *TestHandlerError) ServeHTTP(writer http.ResponseWriter, req *http.Req
 
 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{}}
+       arv := &arvadosclient.ArvadosClient{ApiToken: "abc123"}
+       kc := keepclient.KeepClient{Arvados: arv, Client: &http.Client{}}
        kc.SetServiceRoots(map[string]string{"xxxx": server.URL},
                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)
@@ -93,59 +94,6 @@ func (s *KeepSuite) TestSendTrashListUnreachable(c *C) {
        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
@@ -153,7 +101,7 @@ type APITestData struct {
 }
 
 func (s *KeepSuite) TestGetKeepServers_UnsupportedServiceType(c *C) {
-       testGetKeepServersFromAPI(c, APITestData{1, "notadisk", 200}, "Unsupported service type")
+       testGetKeepServersFromAPI(c, APITestData{1, "notadisk", 200}, "Found no keepservices with the service type disk")
 }
 
 func (s *KeepSuite) TestGetKeepServers_ReceivedTooFewServers(c *C) {
@@ -177,21 +125,21 @@ func testGetKeepServersFromAPI(c *C, testData APITestData, expectedError string)
        }
 
        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()
 
-       arv := arvadosclient.ArvadosClient{
+       arv := &arvadosclient.ArvadosClient{
                Scheme:    "http",
                ApiServer: api.URL[7:],
                ApiToken:  "abc123",
                Client:    &http.Client{Transport: &http.Transport{}},
        }
 
-       kc := keepclient.KeepClient{Arvados: &arv, Client: &http.Client{}}
+       kc := keepclient.KeepClient{Arvados: arv, Client: &http.Client{}}
        kc.SetServiceRoots(map[string]string{"xxxx": "http://example.com:23456"},
                map[string]string{"xxxx": "http://example.com:23456"},
                map[string]string{})
@@ -221,27 +169,27 @@ 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) {
@@ -254,10 +202,10 @@ func (s *KeepSuite) TestGetKeepServers_ReadServerResponseWithTwoBlocks(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()
 
@@ -278,21 +226,21 @@ func testGetKeepServersAndSummarize(c *C, testData KeepServerTestData) {
                }},
        }
        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()
 
-       arv := arvadosclient.ArvadosClient{
+       arv := &arvadosclient.ArvadosClient{
                Scheme:    "http",
                ApiServer: api.URL[7:],
                ApiToken:  "abc123",
                Client:    &http.Client{Transport: &http.Transport{}},
        }
 
-       kc := keepclient.KeepClient{Arvados: &arv, Client: &http.Client{}}
+       kc := keepclient.KeepClient{Arvados: arv, Client: &http.Client{}}
        kc.SetServiceRoots(map[string]string{"xxxx": ks.URL},
                map[string]string{"xxxx": ks.URL},
                map[string]string{})
@@ -325,11 +273,6 @@ func testGetKeepServersAndSummarize(c *C, testData KeepServerTestData) {
                        }
                }
        } 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)
        }
 }