From 7d8af50aecc935b7b733f3d9f38e1cbd06bf31a9 Mon Sep 17 00:00:00 2001 From: laurentiuNiculae Date: Wed, 13 Apr 2022 09:28:43 +0300 Subject: [PATCH] mocked tests for routes Signed-off-by: laurentiuNiculae --- pkg/api/routes.go | 8 - pkg/api/routes_test.go | 1642 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1642 insertions(+), 8 deletions(-) create mode 100644 pkg/api/routes_test.go diff --git a/pkg/api/routes.go b/pkg/api/routes.go index 382b7f71..69a5afbd 100644 --- a/pkg/api/routes.go +++ b/pkg/api/routes.go @@ -955,14 +955,6 @@ func (rh *RouteHandler) PatchBlobUpload(response http.ResponseWriter, request *h return } - contentRange := request.Header.Get("Content-Range") - if contentRange == "" { - rh.c.Log.Warn().Str("actual", request.Header.Get("Content-Range")).Msg("invalid content range") - response.WriteHeader(http.StatusRequestedRangeNotSatisfiable) - - return - } - var from, to int64 if from, to, err = getContentRange(request); err != nil || (to-from)+1 != contentLength { response.WriteHeader(http.StatusRequestedRangeNotSatisfiable) diff --git a/pkg/api/routes_test.go b/pkg/api/routes_test.go new file mode 100644 index 00000000..f4ddb3a9 --- /dev/null +++ b/pkg/api/routes_test.go @@ -0,0 +1,1642 @@ +//go:build extended +// +build extended + +package api_test + +import ( + "bytes" + "context" + "errors" + "io" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/gorilla/mux" + "github.com/opencontainers/go-digest" + ispec "github.com/opencontainers/image-spec/specs-go/v1" + artifactspec "github.com/oras-project/artifacts-spec/specs-go/v1" + . "github.com/smartystreets/goconvey/convey" + zerr "zotregistry.io/zot/errors" + "zotregistry.io/zot/pkg/api" + "zotregistry.io/zot/pkg/api/config" + "zotregistry.io/zot/pkg/api/constants" + "zotregistry.io/zot/pkg/storage" + "zotregistry.io/zot/pkg/test" +) + +var ErrUnexpectedError = errors.New("error: unexpected error") + +type MockedImageStore struct { + dirExistsFn func(d string) bool + rootDirFn func() string + initRepoFn func(name string) error + validateRepoFn func(name string) (bool, error) + getRepositoriesFn func() ([]string, error) + getImageTagsFn func(repo string) ([]string, error) + getImageManifestFn func(repo string, reference string) ([]byte, string, string, error) + putImageManifestFn func(repo string, reference string, mediaType string, body []byte) (string, error) + deleteImageManifestFn func(repo string, reference string) error + blobUploadPathFn func(repo string, uuid string) string + newBlobUploadFn func(repo string) (string, error) + getBlobUploadFn func(repo string, uuid string) (int64, error) + blobUploadInfoFn func(repo string, uuid string) (int64, error) + putBlobChunkStreamedFn func(repo string, uuid string, body io.Reader) (int64, error) + putBlobChunkFn func(repo string, uuid string, from int64, to int64, body io.Reader) (int64, error) + finishBlobUploadFn func(repo string, uuid string, body io.Reader, digest string) error + fullBlobUploadFn func(repo string, body io.Reader, digest string) (string, int64, error) + dedupeBlobFn func(src string, dstDigest digest.Digest, dst string) error + deleteBlobUploadFn func(repo string, uuid string) error + blobPathFn func(repo string, digest digest.Digest) string + checkBlobFn func(repo string, digest string) (bool, int64, error) + getBlobFn func(repo string, digest string, mediaType string) (io.Reader, int64, error) + deleteBlobFn func(repo string, digest string) error + getIndexContentFn func(repo string) ([]byte, error) + getBlobContentFn func(repo, digest string) ([]byte, error) + getReferrersFn func(repo, digest string, mediaType string) ([]artifactspec.Descriptor, error) + urlForPathFn func(path string) (string, error) + runGCPeriodicallyFn func(gcInterval time.Duration) +} + +func (is *MockedImageStore) Lock(t *time.Time) { +} + +func (is *MockedImageStore) Unlock(t *time.Time) { +} + +func (is *MockedImageStore) RUnlock(t *time.Time) { +} + +func (is *MockedImageStore) RLock(t *time.Time) { +} + +func (is *MockedImageStore) DirExists(d string) bool { + if is != nil && is.dirExistsFn != nil { + return is.dirExistsFn(d) + } + + return true +} + +func (is *MockedImageStore) RootDir() string { + if is != nil && is.rootDirFn != nil { + return is.rootDirFn() + } + + return "" +} + +func (is *MockedImageStore) InitRepo(name string) error { + if is != nil && is.initRepoFn != nil { + return is.initRepoFn(name) + } + + return nil +} + +func (is *MockedImageStore) ValidateRepo(name string) (bool, error) { + if is != nil && is.validateRepoFn != nil { + return is.validateRepoFn(name) + } + + return true, nil +} + +func (is *MockedImageStore) GetRepositories() ([]string, error) { + if is != nil && is.getRepositoriesFn != nil { + return is.getRepositoriesFn() + } + + return []string{}, nil +} + +func (is *MockedImageStore) GetImageManifest(repo string, reference string) ([]byte, string, string, error) { + if is != nil && is.getImageManifestFn != nil { + return is.getImageManifestFn(repo, reference) + } + + return []byte{}, "", "", nil +} + +func (is *MockedImageStore) PutImageManifest( + repo string, + reference string, + mediaType string, + body []byte, +) (string, error) { + if is != nil && is.putImageManifestFn != nil { + return is.putImageManifestFn(repo, reference, mediaType, body) + } + + return "", nil +} + +func (is *MockedImageStore) GetImageTags(name string) ([]string, error) { + if is != nil && is.getImageTagsFn != nil { + return is.getImageTagsFn(name) + } + + return []string{}, nil +} + +func (is *MockedImageStore) DeleteImageManifest(name string, reference string) error { + if is != nil && is.deleteImageManifestFn != nil { + return is.deleteImageManifestFn(name, reference) + } + + return nil +} + +func (is *MockedImageStore) NewBlobUpload(repo string) (string, error) { + if is != nil && is.newBlobUploadFn != nil { + return is.newBlobUploadFn(repo) + } + + return "", nil +} + +func (is *MockedImageStore) GetBlobUpload(repo string, uuid string) (int64, error) { + if is != nil && is.getBlobUploadFn != nil { + return is.getBlobUploadFn(repo, uuid) + } + + return 0, nil +} + +func (is *MockedImageStore) BlobUploadInfo(repo string, uuid string) (int64, error) { + if is != nil && is.blobUploadInfoFn != nil { + return is.blobUploadInfoFn(repo, uuid) + } + + return 0, nil +} + +func (is *MockedImageStore) BlobUploadPath(repo string, uuid string) string { + if is != nil && is.blobUploadPathFn != nil { + return is.blobUploadPathFn(repo, uuid) + } + + return "" +} + +func (is *MockedImageStore) PutBlobChunkStreamed(repo string, uuid string, body io.Reader) (int64, error) { + if is != nil && is.putBlobChunkStreamedFn != nil { + return is.putBlobChunkStreamedFn(repo, uuid, body) + } + + return 0, nil +} + +func (is *MockedImageStore) PutBlobChunk( + repo string, + uuid string, + from int64, + to int64, + body io.Reader, +) (int64, error) { + if is != nil && is.putBlobChunkFn != nil { + return is.putBlobChunkFn(repo, uuid, from, to, body) + } + + return 0, nil +} + +func (is *MockedImageStore) FinishBlobUpload(repo string, uuid string, body io.Reader, digest string) error { + if is != nil && is.finishBlobUploadFn != nil { + return is.finishBlobUploadFn(repo, uuid, body, digest) + } + + return nil +} + +func (is *MockedImageStore) FullBlobUpload(repo string, body io.Reader, digest string) (string, int64, error) { + if is != nil && is.fullBlobUploadFn != nil { + return is.fullBlobUploadFn(repo, body, digest) + } + + return "", 0, nil +} + +func (is *MockedImageStore) DedupeBlob(src string, dstDigest digest.Digest, dst string) error { + if is != nil && is.dedupeBlobFn != nil { + return is.dedupeBlobFn(src, dstDigest, dst) + } + + return nil +} + +func (is *MockedImageStore) DeleteBlob(repo string, digest string) error { + if is != nil && is.deleteBlobFn != nil { + return is.deleteBlobFn(repo, digest) + } + + return nil +} + +func (is *MockedImageStore) BlobPath(repo string, digest digest.Digest) string { + if is != nil && is.blobPathFn != nil { + return is.blobPathFn(repo, digest) + } + + return "" +} + +func (is *MockedImageStore) CheckBlob(repo string, digest string) (bool, int64, error) { + if is != nil && is.checkBlobFn != nil { + return is.checkBlobFn(repo, digest) + } + + return true, 0, nil +} + +func (is *MockedImageStore) GetBlob(repo string, digest string, mediaType string) (io.Reader, int64, error) { + if is != nil && is.getBlobFn != nil { + return is.getBlobFn(repo, digest, mediaType) + } + + return &io.LimitedReader{}, 0, nil +} + +func (is *MockedImageStore) DeleteBlobUpload(repo string, digest string) error { + if is != nil && is.deleteBlobUploadFn != nil { + return is.deleteBlobUploadFn(repo, digest) + } + + return nil +} + +func (is *MockedImageStore) GetIndexContent(repo string) ([]byte, error) { + if is != nil && is.getIndexContentFn != nil { + return is.getIndexContentFn(repo) + } + + return []byte{}, nil +} + +func (is *MockedImageStore) GetBlobContent(repo string, digest string) ([]byte, error) { + if is != nil && is.getBlobContentFn != nil { + return is.getBlobContentFn(repo, digest) + } + + return []byte{}, nil +} + +func (is *MockedImageStore) GetReferrers( + repo string, + digest string, + mediaType string, +) ([]artifactspec.Descriptor, error) { + if is != nil && is.getReferrersFn != nil { + return is.getReferrersFn(repo, digest, mediaType) + } + + return []artifactspec.Descriptor{}, nil +} + +func (is *MockedImageStore) URLForPath(path string) (string, error) { + if is != nil && is.urlForPathFn != nil { + return is.urlForPathFn(path) + } + + return "", nil +} + +func (is *MockedImageStore) RunGCPeriodically(gcInterval time.Duration) { + if is != nil && is.runGCPeriodicallyFn != nil { + is.runGCPeriodicallyFn(gcInterval) + } +} + +func TestRoutes(t *testing.T) { + Convey("Make a new controller", t, func() { + port := test.GetFreePort() + baseURL := test.GetBaseURL(port) + conf := config.New() + conf.HTTP.Port = port + + ctlr := api.NewController(conf) + + ctlr.Config.Storage.RootDirectory = t.TempDir() + ctlr.Config.Storage.Commit = true + + err := test.CopyFiles("../../test/data", ctlr.Config.Storage.RootDirectory) + if err != nil { + panic(err) + } + + go startServer(ctlr) + defer stopServer(ctlr) + test.WaitTillServerReady(baseURL) + + rthdlr := api.NewRouteHandler(ctlr) + + // NOTE: the url or method itself doesn't matter below since we are calling the handlers directly, + // so path routing is bypassed + + Convey("Get manifest", func() { + // overwrite controller storage + ctlr.StoreController.DefaultStore = &MockedImageStore{ + getImageManifestFn: func(repo string, reference string) ([]byte, string, string, error) { + return []byte{}, "", "", zerr.ErrRepoBadVersion + }, + } + + request, _ := http.NewRequestWithContext(context.TODO(), "GET", baseURL, nil) + request = mux.SetURLVars(request, map[string]string{ + "name": "test", + "reference": "b8b1231908844a55c251211c7a67ae3c809fb86a081a8eeb4a715e6d7d65625c", + }) + response := httptest.NewRecorder() + + rthdlr.GetManifest(response, request) + + resp := response.Result() + + defer resp.Body.Close() + So(resp, ShouldNotBeNil) + So(resp.StatusCode, ShouldEqual, http.StatusNotFound) + }) + + Convey("UpdateManifest ", func() { + testUpdateManifest := func(urlVars map[string]string, ism *MockedImageStore) int { + ctlr.StoreController.DefaultStore = ism + str := []byte("test") + request, _ := http.NewRequestWithContext(context.TODO(), "PUT", baseURL, bytes.NewBuffer(str)) + request = mux.SetURLVars(request, urlVars) + request.Header.Add("Content-Type", ispec.MediaTypeImageManifest) + response := httptest.NewRecorder() + + rthdlr.UpdateManifest(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + // repo not found + statusCode := testUpdateManifest( + map[string]string{ + "name": "test", + "reference": "reference", + }, + &MockedImageStore{ + putImageManifestFn: func(repo, reference, mediaType string, body []byte) (string, error) { + return "", zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + // ErrManifestNotFound + statusCode = testUpdateManifest( + map[string]string{ + "name": "test", + "reference": "reference", + }, + + &MockedImageStore{ + putImageManifestFn: func(repo, reference, mediaType string, body []byte) (string, error) { + return "", zerr.ErrManifestNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + // ErrBadManifest + statusCode = testUpdateManifest( + map[string]string{ + "name": "test", + "reference": "reference", + }, + &MockedImageStore{ + putImageManifestFn: func(repo, reference, mediaType string, body []byte) (string, error) { + return "", zerr.ErrBadManifest + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + // ErrBlobNotFound + statusCode = testUpdateManifest( + map[string]string{ + "name": "test", + "reference": "reference", + }, + &MockedImageStore{ + putImageManifestFn: func(repo, reference, mediaType string, body []byte) (string, error) { + return "", zerr.ErrBlobNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrRepoBadVersion + statusCode = testUpdateManifest( + map[string]string{ + "name": "test", + "reference": "reference", + }, + &MockedImageStore{ + putImageManifestFn: func(repo, reference, mediaType string, body []byte) (string, error) { + return "", zerr.ErrRepoBadVersion + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("DeleteManifest", func() { + testDeleteManifest := func(headers map[string]string, urlVars map[string]string, ism *MockedImageStore) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.Background(), "DELETE", baseURL, nil) + request = mux.SetURLVars(request, urlVars) + for k, v := range headers { + request.Header.Add(k, v) + } + response := httptest.NewRecorder() + + rthdlr.DeleteManifest(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + // ErrRepoNotFound + statusCode := testDeleteManifest( + map[string]string{}, + map[string]string{ + "name": "ErrManifestNotFound", + "reference": "reference", + }, + &MockedImageStore{ + deleteImageManifestFn: func(repo, reference string) error { + return zerr.ErrRepoNotFound + }, + }, + ) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrManifestNotFound + statusCode = testDeleteManifest( + map[string]string{}, + map[string]string{ + "name": "ErrManifestNotFound", + "reference": "reference", + }, + &MockedImageStore{ + deleteImageManifestFn: func(repo, reference string) error { + return zerr.ErrManifestNotFound + }, + }, + ) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrUnexpectedError + statusCode = testDeleteManifest( + map[string]string{}, + map[string]string{ + "name": "ErrUnexpectedError", + "reference": "reference", + }, + &MockedImageStore{ + deleteImageManifestFn: func(repo, reference string) error { + return ErrUnexpectedError + }, + }, + ) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + + // ErrBadManifest + statusCode = testDeleteManifest( + map[string]string{}, + map[string]string{ + "name": "ErrBadManifest", + "reference": "reference", + }, + &MockedImageStore{ + deleteImageManifestFn: func(repo, reference string) error { + return zerr.ErrBadManifest + }, + }, + ) + So(statusCode, ShouldEqual, http.StatusBadRequest) + }) + + Convey("DeleteBlob", func() { + testDeleteBlob := func(urlVars map[string]string, ism *MockedImageStore) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "DELETE", baseURL, nil) + request = mux.SetURLVars(request, urlVars) + response := httptest.NewRecorder() + + rthdlr.DeleteBlob(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + // ErrUnexpectedError + statusCode := testDeleteBlob( + map[string]string{ + "name": "ErrUnexpectedError", + "digest": "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + deleteBlobFn: func(repo, digest string) error { + return ErrUnexpectedError + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + + statusCode = testDeleteBlob( + map[string]string{ + "name": "ErrBadBlobDigest", + "digest": "sha256:7b8437f04f83f084b7ed68ad8c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + deleteBlobFn: func(repo, digest string) error { + return zerr.ErrBadBlobDigest + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrBlobNotFound + statusCode = testDeleteBlob( + map[string]string{ + "name": "ErrBlobNotFound", + "digest": "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + deleteBlobFn: func(repo, digest string) error { + return zerr.ErrBlobNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrRepoNotFound + statusCode = testDeleteBlob( + map[string]string{ + "name": "ErrRepoNotFound", + "digest": "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + deleteBlobFn: func(repo, digest string) error { + return zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + }) + + // Check Blob + Convey("CheckBlob", func() { + testCheckBlob := func(urlVars map[string]string, ism *MockedImageStore) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "HEAD", baseURL, nil) + request = mux.SetURLVars(request, urlVars) + response := httptest.NewRecorder() + + rthdlr.CheckBlob(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + // ErrBadBlobDigest + statusCode := testCheckBlob( + map[string]string{ + "name": "ErrBadBlobDigest", + "digest": "1234", + }, + &MockedImageStore{ + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrBadBlobDigest + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrRepoNotFound + statusCode = testCheckBlob( + map[string]string{ + "name": "ErrRepoNotFound", + "digest": "1234", + }, + &MockedImageStore{ + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrBlobNotFound + statusCode = testCheckBlob( + map[string]string{ + "name": "ErrBlobNotFound", + "digest": "1234", + }, + &MockedImageStore{ + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrBlobNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrUnexpectedError + statusCode = testCheckBlob( + map[string]string{ + "name": "ErrUnexpectedError", + "digest": "1234", + }, + &MockedImageStore{ + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, ErrUnexpectedError + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + + // Error Check Blob is not ok + statusCode = testCheckBlob( + map[string]string{ + "name": "Check Blob Not Ok", + "digest": "1234", + }, + &MockedImageStore{ + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return false, 0, nil + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + }) + + Convey("GetBlob", func() { + testGetBlob := func(urlVars map[string]string, ism *MockedImageStore) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "GET", baseURL, nil) + request = mux.SetURLVars(request, urlVars) + response := httptest.NewRecorder() + + rthdlr.GetBlob(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + // ErrRepoNotFound + statusCode := testGetBlob( + map[string]string{ + "name": "ErrRepoNotFound", + "digest": "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + getBlobFn: func(repo, digest, mediaType string) (io.Reader, int64, error) { + return bytes.NewBuffer([]byte("")), 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrRepoNotFound + statusCode = testGetBlob( + map[string]string{ + "name": "ErrRepoNotFound", + "digest": "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621", + }, + &MockedImageStore{ + getBlobFn: func(repo, digest, mediaType string) (io.Reader, int64, error) { + return bytes.NewBuffer([]byte("")), 0, zerr.ErrBadBlobDigest + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + }) + + Convey("CreateBlobUpload", func() { + testCreateBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "POST", baseURL, nil) + request = mux.SetURLVars(request, + map[string]string{ + "name": "test", + "mount": "1234", + }) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.CreateBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + // ErrRepoNotFound + statusCode := testCreateBlobUpload( + []struct{ k, v string }{ + {"mount", "1234"}, + }, + map[string]string{}, + &MockedImageStore{ + newBlobUploadFn: func(repo string) (string, error) { + return "", zerr.ErrRepoNotFound + }, + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // a full blob upload if multiple digests are present + statusCode = testCreateBlobUpload( + []struct{ k, v string }{ + {"digest", "1234"}, + {"digest", "5234"}, + }, + map[string]string{}, + &MockedImageStore{ + newBlobUploadFn: func(repo string) (string, error) { + return "", zerr.ErrRepoNotFound + }, + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // a full blob upload if content type is wrong + statusCode = testCreateBlobUpload( + []struct{ k, v string }{ + {"digest", "1234"}, + }, + map[string]string{ + "Content-Type": "badContentType", + }, + &MockedImageStore{ + newBlobUploadFn: func(repo string) (string, error) { + return "", zerr.ErrRepoNotFound + }, + checkBlobFn: func(repo, digest string) (bool, int64, error) { + return true, 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusUnsupportedMediaType) + + // digest prezent imgStore err + statusCode = testCreateBlobUpload( + []struct{ k, v string }{ + {"digest", "1234"}, + }, + map[string]string{ + "Content-Type": constants.BinaryMediaType, + "Content-Length": "100", + }, + &MockedImageStore{ + fullBlobUploadFn: func(repo string, body io.Reader, digest string) (string, int64, error) { + return "session", 0, zerr.ErrBadBlobDigest + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + + // digest prezent bad length + statusCode = testCreateBlobUpload( + []struct{ k, v string }{ + {"digest", "1234"}, + }, + map[string]string{ + "Content-Type": constants.BinaryMediaType, + "Content-Length": "100", + }, + &MockedImageStore{ + fullBlobUploadFn: func(repo string, body io.Reader, digest string) (string, int64, error) { + return "session", 20, nil + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + + // newBlobUpload not found + statusCode = testCreateBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Type": constants.BinaryMediaType, + "Content-Length": "100", + }, + &MockedImageStore{ + newBlobUploadFn: func(repo string) (string, error) { + return "", zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // newBlobUpload unexpected error + statusCode = testCreateBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Type": constants.BinaryMediaType, + "Content-Length": "100", + }, + &MockedImageStore{ + newBlobUploadFn: func(repo string) (string, error) { + return "", ErrUnexpectedError + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("GetBlobUpload", func() { + testGetBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "GET", baseURL, nil) + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.GetBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + // ErrBadUploadRange + statusCode := testGetBlobUpload( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "test", + "session_id": "1234", + }, + &MockedImageStore{ + getBlobUploadFn: func(repo, uuid string) (int64, error) { + return 0, zerr.ErrBadUploadRange + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrBadBlobDigest + statusCode = testGetBlobUpload( + []struct{ k, v string }{ + {"mount", "1234"}, + }, + map[string]string{}, + map[string]string{ + "name": "test", + "session_id": "1234", + }, + &MockedImageStore{ + getBlobUploadFn: func(repo, uuid string) (int64, error) { + return 0, zerr.ErrBadBlobDigest + }, + }) + So(statusCode, ShouldEqual, http.StatusBadRequest) + + // ErrRepoNotFound + statusCode = testGetBlobUpload( + []struct{ k, v string }{ + {"mount", "1234"}, + }, + map[string]string{}, + map[string]string{ + "name": "test", + "session_id": "1234", + }, + &MockedImageStore{ + getBlobUploadFn: func(repo, uuid string) (int64, error) { + return 0, zerr.ErrRepoNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrUploadNotFound + statusCode = testGetBlobUpload( + []struct{ k, v string }{ + {"mount", "1234"}, + }, + map[string]string{}, + map[string]string{ + "name": "test", + "session_id": "1234", + }, + &MockedImageStore{ + getBlobUploadFn: func(repo, uuid string) (int64, error) { + return 0, zerr.ErrUploadNotFound + }, + }) + So(statusCode, ShouldEqual, http.StatusNotFound) + + // ErrUploadNotFound + statusCode = testGetBlobUpload( + []struct{ k, v string }{ + {"mount", "1234"}, + }, + map[string]string{}, + map[string]string{ + "name": "test", + "session_id": "1234", + }, + &MockedImageStore{ + getBlobUploadFn: func(repo, uuid string) (int64, error) { + return 0, ErrUnexpectedError + }, + }) + So(statusCode, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("PatchBlobUpload", func() { + testPatchBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "PATCH", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.PatchBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + status := testPatchBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Length": "abc", + "Content-Range": "abc", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{}, + ) + So(status, ShouldEqual, http.StatusBadRequest) + + status = testPatchBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-50", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{}, + ) + So(status, ShouldEqual, http.StatusRequestedRangeNotSatisfiable) + + status = testPatchBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 100, zerr.ErrRepoNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testPatchBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 100, zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testPatchBlobUpload( + []struct{ k, v string }{}, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 100, ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("UpdateBlobUpload", func() { + testUpdateBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "PATCH", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.UpdateBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + status := testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{}, + ) + So(status, ShouldEqual, http.StatusBadRequest) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "100", + "Content-Range": "badRange", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{}, + ) + So(status, ShouldEqual, http.StatusRequestedRangeNotSatisfiable) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 0, zerr.ErrBadUploadRange + }, + }, + ) + So(status, ShouldEqual, http.StatusBadRequest) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 0, zerr.ErrRepoNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 0, zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "100", + "Content-Range": "1-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + putBlobChunkFn: func(repo, uuid string, from, to int64, body io.Reader) (int64, error) { + return 0, ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrBadBlobDigest + }, + }, + ) + So(status, ShouldEqual, http.StatusBadRequest) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrBadUploadRange + }, + }, + ) + So(status, ShouldEqual, http.StatusBadRequest) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrRepoNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("DeleteBlobUpload", func() { + testDeleteBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "PATCH", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.DeleteBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + status := testDeleteBlobUpload( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + deleteBlobUploadFn: func(repo, uuid string) error { + return zerr.ErrRepoNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testDeleteBlobUpload( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + deleteBlobUploadFn: func(repo, uuid string) error { + return zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusNotFound) + + status = testDeleteBlobUpload( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + deleteBlobUploadFn: func(repo, uuid string) error { + return ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("ListRepositories", func() { + testListRepositoriesWithSubstores := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + ctlr.StoreController.SubStore = map[string]storage.ImageStore{ + "test": &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{}, ErrUnexpectedError + }, + }, + } + request, _ := http.NewRequestWithContext(context.TODO(), "GET", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.ListRepositories(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + testListRepositories := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + ctlr.StoreController.SubStore = map[string]storage.ImageStore{} + request, _ := http.NewRequestWithContext(context.TODO(), "PATCH", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.ListRepositories(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + // with substores + status := testListRepositoriesWithSubstores( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{}, ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + + status = testListRepositories( + []struct{ k, v string }{}, + map[string]string{}, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{}, ErrUnexpectedError + }, + }, + ) + So(status, ShouldEqual, http.StatusInternalServerError) + }) + + Convey("ListRepositories with Authz", func() { + ctlr.StoreController.DefaultStore = &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{"repo"}, nil + }, + } + ctlr.StoreController.SubStore = map[string]storage.ImageStore{ + "test1": &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{"repo1"}, nil + }, + }, + "test2": &MockedImageStore{ + getRepositoriesFn: func() ([]string, error) { + return []string{"repo2"}, nil + }, + }, + } + + // make the user an admin + // acCtx := api.NewAccessControlContext(map[string]bool{}, true) + // ctx := context.WithValue(context.Background(), "ctx", acCtx) + ctx := context.Background() + request, _ := http.NewRequestWithContext(ctx, "GET", baseURL, nil) + request = mux.SetURLVars(request, map[string]string{ + "name": "repo", + "session_id": "test", + }) + response := httptest.NewRecorder() + + rthdlr.ListRepositories(response, request) + + resp := response.Result() + defer resp.Body.Close() + + So(resp.StatusCode, ShouldEqual, http.StatusOK) + }) + + Convey("Helper functions", func() { + testUpdateBlobUpload := func( + query []struct{ k, v string }, + headers map[string]string, + vars map[string]string, + ism *MockedImageStore, + ) int { + ctlr.StoreController.DefaultStore = ism + request, _ := http.NewRequestWithContext(context.TODO(), "PATCH", baseURL, nil) + + request = mux.SetURLVars(request, vars) + + q := request.URL.Query() + for _, qe := range query { + q.Add(qe.k, qe.v) + } + request.URL.RawQuery = q.Encode() + + for k, v := range headers { + request.Header.Add(k, v) + } + + response := httptest.NewRecorder() + + rthdlr.UpdateBlobUpload(response, request) + + resp := response.Result() + defer resp.Body.Close() + + return resp.StatusCode + } + + status := testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "a-100", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusRequestedRangeNotSatisfiable) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "20-a", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusRequestedRangeNotSatisfiable) + + status = testUpdateBlobUpload( + []struct{ k, v string }{ + {"digest", "sha256:7a0437f04f83f084b7ed68ad9c4a4947e12fc4e1b006b38129bac89114ec3621"}, + }, + map[string]string{ + "Content-Length": "0", + "Content-Range": "20-1", + }, + map[string]string{ + "name": "repo", + "session_id": "test", + }, + &MockedImageStore{ + finishBlobUploadFn: func(repo, uuid string, body io.Reader, digest string) error { + return zerr.ErrUploadNotFound + }, + }, + ) + So(status, ShouldEqual, http.StatusRequestedRangeNotSatisfiable) + }) + }) +}