From 3f0faedfd8b402eff3eb196c1f5c00d67401a5b2 Mon Sep 17 00:00:00 2001 From: Marius Date: Thu, 13 Oct 2016 11:33:20 +0200 Subject: [PATCH] Use mocks generated by gomock for running tests --- concat_test.go | 353 +++++++++++++++++---------------- get_test.go | 73 +++---- handler_mock_test.go | 96 +++++++++ handler_test.go | 84 +++++--- head_test.go | 112 ++++++----- options_test.go | 2 +- post_test.go | 462 ++++++++++++++++++++++++------------------- terminate_test.go | 118 ++++++----- 8 files changed, 732 insertions(+), 568 deletions(-) create mode 100644 handler_mock_test.go diff --git a/concat_test.go b/concat_test.go index 0a1a108..f8e31e8 100644 --- a/concat_test.go +++ b/concat_test.go @@ -4,200 +4,205 @@ import ( "net/http" "testing" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" . "github.com/tus/tusd" ) -type concatPartialStore struct { - t *assert.Assertions - zeroStore -} +func TestConcat(t *testing.T) { + SubTest(t, "ExtensionDiscovery", func(t *testing.T, store *MockFullDataStore) { + composer := NewStoreComposer() + composer.UseCore(store) + composer.UseConcater(store) -func (s concatPartialStore) NewUpload(info FileInfo) (string, error) { - s.t.True(info.IsPartial) - s.t.False(info.IsFinal) - s.t.Nil(info.PartialUploads) + handler, _ := NewHandler(Config{ + StoreComposer: composer, + }) - return "foo", nil -} - -func (s concatPartialStore) GetInfo(id string) (FileInfo, error) { - return FileInfo{ - IsPartial: true, - }, nil -} - -func (s concatPartialStore) ConcatUploads(id string, uploads []string) error { - return nil -} - -func TestConcatPartial(t *testing.T) { - handler, _ := NewHandler(Config{ - MaxSize: 400, - BasePath: "files", - DataStore: concatPartialStore{ - t: assert.New(t), - }, + (&httpTest{ + Method: "OPTIONS", + Code: http.StatusOK, + ResHeader: map[string]string{ + "Tus-Extension": "creation,creation-with-upload,concatenation", + }, + }).Run(handler, t) }) - (&httpTest{ - Name: "Successful OPTIONS request", - Method: "OPTIONS", - URL: "", - ResHeader: map[string]string{ - "Tus-Extension": "creation,creation-with-upload,concatenation", - }, - Code: http.StatusOK, - }).Run(handler, t) + SubTest(t, "Partial", func(t *testing.T, store *MockFullDataStore) { + SubTest(t, "Create", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + IsPartial: true, + IsFinal: false, + PartialUploads: nil, + MetaData: make(map[string]string), + }).Return("foo", nil) - (&httpTest{ - Name: "Successful POST request", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Concat": "partial", - }, - Code: http.StatusCreated, - }).Run(handler, t) + handler, _ := NewHandler(Config{ + BasePath: "files", + DataStore: store, + }) - (&httpTest{ - Name: "Successful HEAD request", - Method: "HEAD", - URL: "foo", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusOK, - ResHeader: map[string]string{ - "Upload-Concat": "partial", - }, - }).Run(handler, t) -} + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Upload-Concat": "partial", + }, + Code: http.StatusCreated, + }).Run(handler, t) + }) -type concatFinalStore struct { - t *assert.Assertions - zeroStore -} + SubTest(t, "Status", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("foo").Return(FileInfo{ + IsPartial: true, + }, nil) -func (s concatFinalStore) NewUpload(info FileInfo) (string, error) { - s.t.False(info.IsPartial) - s.t.True(info.IsFinal) - s.t.Equal([]string{"a", "b"}, info.PartialUploads) + handler, _ := NewHandler(Config{ + BasePath: "files", + DataStore: store, + }) - return "foo", nil -} - -func (s concatFinalStore) GetInfo(id string) (FileInfo, error) { - if id == "a" || id == "b" { - return FileInfo{ - IsPartial: true, - Size: 5, - Offset: 5, - }, nil - } - - if id == "c" { - return FileInfo{ - IsPartial: true, - Size: 5, - Offset: 3, - }, nil - } - - if id == "foo" { - return FileInfo{ - IsFinal: true, - PartialUploads: []string{"a", "b"}, - Size: 10, - Offset: 10, - }, nil - } - - return FileInfo{}, ErrNotFound -} - -func (s concatFinalStore) ConcatUploads(id string, uploads []string) error { - s.t.Equal("foo", id) - s.t.Equal([]string{"a", "b"}, uploads) - - return nil -} - -func TestConcatFinal(t *testing.T) { - a := assert.New(t) - - handler, _ := NewHandler(Config{ - MaxSize: 400, - BasePath: "files", - DataStore: concatFinalStore{ - t: a, - }, - NotifyCompleteUploads: true, + (&httpTest{ + Method: "HEAD", + URL: "foo", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusOK, + ResHeader: map[string]string{ + "Upload-Concat": "partial", + }, + }).Run(handler, t) + }) }) - c := make(chan FileInfo, 1) - handler.CompleteUploads = c + SubTest(t, "Final", func(t *testing.T, store *MockFullDataStore) { + SubTest(t, "Create", func(t *testing.T, store *MockFullDataStore) { + a := assert.New(t) - (&httpTest{ - Name: "Successful POST request", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Concat": "final; http://tus.io/files/a /files/b/", - }, - Code: http.StatusCreated, - }).Run(handler, t) + gomock.InOrder( + store.EXPECT().GetInfo("a").Return(FileInfo{ + IsPartial: true, + Size: 5, + Offset: 5, + }, nil), + store.EXPECT().GetInfo("b").Return(FileInfo{ + IsPartial: true, + Size: 5, + Offset: 5, + }, nil), + store.EXPECT().NewUpload(FileInfo{ + Size: 10, + IsPartial: false, + IsFinal: true, + PartialUploads: []string{"a", "b"}, + MetaData: make(map[string]string), + }).Return("foo", nil), + store.EXPECT().ConcatUploads("foo", []string{"a", "b"}).Return(nil), + ) - info := <-c - a.Equal("foo", info.ID) - a.Equal(int64(10), info.Size) - a.Equal(int64(10), info.Offset) - a.False(info.IsPartial) - a.True(info.IsFinal) - a.Equal([]string{"a", "b"}, info.PartialUploads) + handler, _ := NewHandler(Config{ + BasePath: "files", + DataStore: store, + NotifyCompleteUploads: true, + }) - (&httpTest{ - Name: "Successful HEAD request", - Method: "HEAD", - URL: "foo", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusOK, - ResHeader: map[string]string{ - "Upload-Concat": "final; http://tus.io/files/a http://tus.io/files/b", - "Upload-Length": "10", - "Upload-Offset": "10", - }, - }).Run(handler, t) + c := make(chan FileInfo, 1) + handler.CompleteUploads = c - (&httpTest{ - Name: "Concatenating non finished upload (id: c)", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Concat": "final; http://tus.io/files/c", - }, - Code: http.StatusBadRequest, - }).Run(handler, t) + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Concat": "final; http://tus.io/files/a /files/b/", + }, + Code: http.StatusCreated, + }).Run(handler, t) - handler, _ = NewHandler(Config{ - MaxSize: 9, - BasePath: "files", - DataStore: concatFinalStore{ - t: assert.New(t), - }, + info := <-c + a.Equal("foo", info.ID) + a.EqualValues(10, info.Size) + a.EqualValues(10, info.Offset) + a.False(info.IsPartial) + a.True(info.IsFinal) + a.Equal([]string{"a", "b"}, info.PartialUploads) + }) + + SubTest(t, "Status", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("foo").Return(FileInfo{ + IsFinal: true, + PartialUploads: []string{"a", "b"}, + Size: 10, + Offset: 10, + }, nil) + + handler, _ := NewHandler(Config{ + BasePath: "files", + DataStore: store, + }) + + (&httpTest{ + Method: "HEAD", + URL: "foo", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusOK, + ResHeader: map[string]string{ + "Upload-Concat": "final; http://tus.io/files/a http://tus.io/files/b", + "Upload-Length": "10", + "Upload-Offset": "10", + }, + }).Run(handler, t) + }) + + SubTest(t, "CreateWithUnfinishedFail", func(t *testing.T, store *MockFullDataStore) { + // This upload is still unfinished (mismatching offset and size) and + // will therefore cause the POST request to fail. + store.EXPECT().GetInfo("c").Return(FileInfo{ + IsPartial: true, + Size: 5, + Offset: 3, + }, nil) + + handler, _ := NewHandler(Config{ + BasePath: "files", + DataStore: store, + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Concat": "final; http://tus.io/files/c", + }, + Code: http.StatusBadRequest, + }).Run(handler, t) + }) + + SubTest(t, "CreateExceedingMaxSizeFail", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("huge").Return(FileInfo{ + Size: 1000, + Offset: 1000, + }, nil) + + handler, _ := NewHandler(Config{ + MaxSize: 100, + BasePath: "files", + DataStore: store, + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Concat": "final; /files/huge", + }, + Code: http.StatusRequestEntityTooLarge, + }).Run(handler, t) + }) }) - - (&httpTest{ - Name: "Exceeding MaxSize", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Concat": "final; http://tus.io/files/a /files/b/", - }, - Code: http.StatusRequestEntityTooLarge, - }).Run(handler, t) } diff --git a/get_test.go b/get_test.go index 5796dde..4c9ecb5 100644 --- a/get_test.go +++ b/get_test.go @@ -1,37 +1,14 @@ package tusd_test import ( - "io" "net/http" - "os" "strings" "testing" + "github.com/golang/mock/gomock" . "github.com/tus/tusd" ) -type getStore struct { - zeroStore -} - -func (s getStore) GetInfo(id string) (FileInfo, error) { - if id != "yes" { - return FileInfo{}, os.ErrNotExist - } - - return FileInfo{ - Offset: 5, - Size: 20, - MetaData: map[string]string{ - "filename": "file.jpg\"evil", - }, - }, nil -} - -func (s getStore) GetReader(id string) (io.Reader, error) { - return reader, nil -} - type closingStringReader struct { *strings.Reader closed bool @@ -47,23 +24,35 @@ var reader = &closingStringReader{ } func TestGet(t *testing.T) { - handler, _ := NewHandler(Config{ - DataStore: getStore{}, + SubTest(t, "Successful download", func(t *testing.T, store *MockFullDataStore) { + gomock.InOrder( + store.EXPECT().GetInfo("yes").Return(FileInfo{ + Offset: 5, + Size: 20, + MetaData: map[string]string{ + "filename": "file.jpg\"evil", + }, + }, nil), + store.EXPECT().GetReader("yes").Return(reader, nil), + ) + + handler, _ := NewHandler(Config{ + DataStore: store, + }) + + (&httpTest{ + Method: "GET", + URL: "yes", + Code: http.StatusOK, + ResBody: "hello", + ResHeader: map[string]string{ + "Content-Length": "5", + "Content-Disposition": `inline;filename="file.jpg\"evil"`, + }, + }).Run(handler, t) + + if !reader.closed { + t.Error("expected reader to be closed") + } }) - - (&httpTest{ - Name: "Successful download", - Method: "GET", - URL: "yes", - Code: http.StatusOK, - ResBody: "hello", - ResHeader: map[string]string{ - "Content-Length": "5", - "Content-Disposition": `inline;filename="file.jpg\"evil"`, - }, - }).Run(handler, t) - - if !reader.closed { - t.Error("expected reader to be closed") - } } diff --git a/handler_mock_test.go b/handler_mock_test.go new file mode 100644 index 0000000..fd292fd --- /dev/null +++ b/handler_mock_test.go @@ -0,0 +1,96 @@ +// Automatically generated by MockGen. DO NOT EDIT! +// Source: handler_test.go + +package tusd_test + +import ( + io "io" + + gomock "github.com/golang/mock/gomock" + tusd "github.com/tus/tusd" +) + +// Mock of FullDataStore interface +type MockFullDataStore struct { + ctrl *gomock.Controller + recorder *_MockFullDataStoreRecorder +} + +// Recorder for MockFullDataStore (not exported) +type _MockFullDataStoreRecorder struct { + mock *MockFullDataStore +} + +func NewMockFullDataStore(ctrl *gomock.Controller) *MockFullDataStore { + mock := &MockFullDataStore{ctrl: ctrl} + mock.recorder = &_MockFullDataStoreRecorder{mock} + return mock +} + +func (_m *MockFullDataStore) EXPECT() *_MockFullDataStoreRecorder { + return _m.recorder +} + +func (_m *MockFullDataStore) NewUpload(info tusd.FileInfo) (string, error) { + ret := _m.ctrl.Call(_m, "NewUpload", info) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +func (_mr *_MockFullDataStoreRecorder) NewUpload(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "NewUpload", arg0) +} + +func (_m *MockFullDataStore) WriteChunk(id string, offset int64, src io.Reader) (int64, error) { + ret := _m.ctrl.Call(_m, "WriteChunk", id, offset, src) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +func (_mr *_MockFullDataStoreRecorder) WriteChunk(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteChunk", arg0, arg1, arg2) +} + +func (_m *MockFullDataStore) GetInfo(id string) (tusd.FileInfo, error) { + ret := _m.ctrl.Call(_m, "GetInfo", id) + ret0, _ := ret[0].(tusd.FileInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +func (_mr *_MockFullDataStoreRecorder) GetInfo(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInfo", arg0) +} + +func (_m *MockFullDataStore) Terminate(id string) error { + ret := _m.ctrl.Call(_m, "Terminate", id) + ret0, _ := ret[0].(error) + return ret0 +} + +func (_mr *_MockFullDataStoreRecorder) Terminate(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Terminate", arg0) +} + +func (_m *MockFullDataStore) ConcatUploads(destination string, partialUploads []string) error { + ret := _m.ctrl.Call(_m, "ConcatUploads", destination, partialUploads) + ret0, _ := ret[0].(error) + return ret0 +} + +func (_mr *_MockFullDataStoreRecorder) ConcatUploads(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ConcatUploads", arg0, arg1) +} + +func (_m *MockFullDataStore) GetReader(id string) (io.Reader, error) { + ret := _m.ctrl.Call(_m, "GetReader", id) + ret0, _ := ret[0].(io.Reader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +func (_mr *_MockFullDataStoreRecorder) GetReader(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetReader", arg0) +} diff --git a/handler_test.go b/handler_test.go index 3a32813..748d325 100644 --- a/handler_test.go +++ b/handler_test.go @@ -1,15 +1,18 @@ package tusd_test import ( + "fmt" "io" + "io/ioutil" "net/http" "net/http/httptest" - "os" + "reflect" "strings" "testing" - "github.com/stretchr/testify/assert" + "github.com/golang/mock/gomock" + "github.com/tus/tusd" . "github.com/tus/tusd" ) @@ -26,6 +29,13 @@ func (store zeroStore) GetInfo(id string) (FileInfo, error) { return FileInfo{}, nil } +type FullDataStore interface { + tusd.DataStore + tusd.TerminaterDataStore + tusd.ConcaterDataStore + tusd.GetReaderDataStore +} + type httpTest struct { Name string @@ -41,8 +51,6 @@ type httpTest struct { } func (test *httpTest) Run(handler http.Handler, t *testing.T) *httptest.ResponseRecorder { - t.Logf("'%s' in %s", test.Name, assert.CallerInfo()[1]) - req, _ := http.NewRequest(test.Method, test.URL, test.ReqBody) // Add headers @@ -73,33 +81,61 @@ func (test *httpTest) Run(handler http.Handler, t *testing.T) *httptest.Response return w } -type methodOverrideStore struct { - zeroStore - t *testing.T - called bool +func SubTest(t *testing.T, name string, runTest func(*testing.T, *MockFullDataStore)) { + t.Run(name, func(subT *testing.T) { + //subT.Parallel() + + ctrl := gomock.NewController(subT) + defer ctrl.Finish() + + store := NewMockFullDataStore(ctrl) + + runTest(subT, store) + }) } -func (s methodOverrideStore) GetInfo(id string) (FileInfo, error) { - if id != "yes" { - return FileInfo{}, os.ErrNotExist +type ReaderMatcher struct { + expect string +} + +func NewReaderMatcher(expect string) gomock.Matcher { + return ReaderMatcher{ + expect: expect, + } +} + +func (m ReaderMatcher) Matches(x interface{}) bool { + input, ok := x.(io.Reader) + if !ok { + return false } - return FileInfo{ - Offset: 5, - Size: 20, - }, nil + bytes, err := ioutil.ReadAll(input) + if err != nil { + panic(err) + } + + readStr := string(bytes) + return reflect.DeepEqual(m.expect, readStr) } -func (s *methodOverrideStore) WriteChunk(id string, offset int64, src io.Reader) (int64, error) { - s.called = true - - return 5, nil +func (m ReaderMatcher) String() string { + return fmt.Sprintf("reads to %s", m.expect) } func TestMethodOverride(t *testing.T) { - store := &methodOverrideStore{ - t: t, - } + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + store := NewMockFullDataStore(mockCtrl) + + store.EXPECT().GetInfo("yes").Return(FileInfo{ + Offset: 5, + Size: 20, + }, nil) + + store.EXPECT().WriteChunk("yes", int64(5), NewReaderMatcher("hello")).Return(int64(5), nil) + handler, _ := NewHandler(Config{ DataStore: store, }) @@ -120,8 +156,4 @@ func TestMethodOverride(t *testing.T) { "Upload-Offset": "10", }, }).Run(handler, t) - - if !store.called { - t.Fatal("WriteChunk implementation not called") - } } diff --git a/head_test.go b/head_test.go index 90c5554..531149c 100644 --- a/head_test.go +++ b/head_test.go @@ -8,67 +8,65 @@ import ( . "github.com/tus/tusd" ) -type headStore struct { - zeroStore -} - -func (s headStore) GetInfo(id string) (FileInfo, error) { - if id != "yes" { - return FileInfo{}, os.ErrNotExist - } - - return FileInfo{ - Offset: 11, - Size: 44, - MetaData: map[string]string{ - "name": "lunrjs.png", - "type": "image/png", - }, - }, nil -} - func TestHead(t *testing.T) { - handler, _ := NewHandler(Config{ - BasePath: "https://buy.art/", - DataStore: headStore{}, + SubTest(t, "Successful HEAD request", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("yes").Return(FileInfo{ + Offset: 11, + Size: 44, + MetaData: map[string]string{ + "name": "lunrjs.png", + "type": "image/png", + }, + }, nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + }) + + res := (&httpTest{ + Name: "Successful request", + Method: "HEAD", + URL: "yes", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusOK, + ResHeader: map[string]string{ + "Upload-Offset": "11", + "Upload-Length": "44", + "Cache-Control": "no-store", + }, + }).Run(handler, t) + + // Since the order of a map is not guaranteed in Go, we need to be prepared + // for the case, that the order of the metadata may have been changed + if v := res.Header().Get("Upload-Metadata"); v != "name bHVucmpzLnBuZw==,type aW1hZ2UvcG5n" && + v != "type aW1hZ2UvcG5n,name bHVucmpzLnBuZw==" { + t.Errorf("Expected valid metadata (got '%s')", v) + } }) - res := (&httpTest{ - Name: "Successful request", - Method: "HEAD", - URL: "yes", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusOK, - ResHeader: map[string]string{ - "Upload-Offset": "11", - "Upload-Length": "44", - "Cache-Control": "no-store", - }, - }).Run(handler, t) + SubTest(t, "Non-existing file", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("no").Return(FileInfo{}, os.ErrNotExist) - // Since the order of a map is not guaranteed in Go, we need to be prepared - // for the case, that the order of the metadata may have been changed - if v := res.Header().Get("Upload-Metadata"); v != "name bHVucmpzLnBuZw==,type aW1hZ2UvcG5n" && - v != "type aW1hZ2UvcG5n,name bHVucmpzLnBuZw==" { - t.Errorf("Expected valid metadata (got '%s')", v) - } + handler, _ := NewHandler(Config{ + DataStore: store, + }) - res = (&httpTest{ - Name: "Non-existing file", - Method: "HEAD", - URL: "no", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusNotFound, - ResHeader: map[string]string{ - "Content-Length": "0", - }, - }).Run(handler, t) + res := (&httpTest{ + Method: "HEAD", + URL: "no", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusNotFound, + ResHeader: map[string]string{ + "Content-Length": "0", + }, + }).Run(handler, t) - if string(res.Body.Bytes()) != "" { - t.Errorf("Expected empty body for failed HEAD request") - } + if string(res.Body.Bytes()) != "" { + t.Errorf("Expected empty body for failed HEAD request") + } + }) } diff --git a/options_test.go b/options_test.go index 2d89ddf..26febd8 100644 --- a/options_test.go +++ b/options_test.go @@ -9,7 +9,7 @@ import ( func TestOptions(t *testing.T) { store := NewStoreComposer() - store.UseCore(zeroStore{}) + store.UseCore(NewMockFullDataStore(nil)) handler, _ := NewHandler(Config{ StoreComposer: store, MaxSize: 400, diff --git a/post_test.go b/post_test.go index ae0a3d1..580a42e 100644 --- a/post_test.go +++ b/post_test.go @@ -2,228 +2,276 @@ package tusd_test import ( "bytes" - "io" - "io/ioutil" "net/http" "strings" "testing" - "github.com/stretchr/testify/assert" + "github.com/golang/mock/gomock" . "github.com/tus/tusd" ) -type postStore struct { - t *assert.Assertions - zeroStore -} - -func (s postStore) NewUpload(info FileInfo) (string, error) { - s.t.Equal(int64(300), info.Size) - - metaData := info.MetaData - s.t.Equal(2, len(metaData)) - s.t.Equal("hello", metaData["foo"]) - s.t.Equal("world", metaData["bar"]) - - return "foo", nil -} - -func (s postStore) WriteChunk(id string, offset int64, src io.Reader) (int64, error) { - s.t.Equal(int64(0), offset) - - data, err := ioutil.ReadAll(src) - s.t.Nil(err) - s.t.Equal("hello", string(data)) - - return 5, nil -} - -func (s postStore) ConcatUploads(id string, uploads []string) error { - s.t.True(false, "concatenation should not be attempted") - return nil -} - func TestPost(t *testing.T) { - a := assert.New(t) + SubTest(t, "Create", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{ + "foo": "hello", + "bar": "world", + }, + }).Return("foo", nil) - handler, _ := NewHandler(Config{ - MaxSize: 400, - BasePath: "files", - DataStore: postStore{ - t: a, - }, + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", + }, + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "http://tus.io/files/foo", + }, + }).Run(handler, t) }) - (&httpTest{ - Name: "Successful request", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - }, - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "http://tus.io/files/foo", - }, - }).Run(handler, t) + SubTest(t, "CreateExceedingMaxSizeFail", func(t *testing.T, store *MockFullDataStore) { + handler, _ := NewHandler(Config{ + MaxSize: 400, + DataStore: store, + BasePath: "/files/", + }) - (&httpTest{ - Name: "Exceeding MaxSize", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "500", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - }, - Code: http.StatusRequestEntityTooLarge, - }).Run(handler, t) - - (&httpTest{ - Name: "Ignore Forwarded headers", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "X-Forwarded-Host": "foo.com", - "X-Forwarded-Proto": "https", - }, - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "http://tus.io/files/foo", - }, - }).Run(handler, t) - - handler, _ = NewHandler(Config{ - MaxSize: 400, - BasePath: "files", - DataStore: postStore{ - t: a, - }, - RespectForwardedHeaders: true, + (&httpTest{ + Name: "Exceeding MaxSize", + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "500", + "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", + }, + Code: http.StatusRequestEntityTooLarge, + }).Run(handler, t) }) - (&httpTest{ - Name: "Respect X-Forwarded-* headers", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "X-Forwarded-Host": "foo.com", - "X-Forwarded-Proto": "https", - }, - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "https://foo.com/files/foo", - }, - }).Run(handler, t) + SubTest(t, "ForwardHeaders", func(t *testing.T, store *MockFullDataStore) { + SubTest(t, "IgnoreXForwarded", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) - (&httpTest{ - Name: "Respect Forwarded headers", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "X-Forwarded-Host": "bar.com", - "X-Forwarded-Proto": "http", - "Forwarded": "proto=https,host=foo.com", - }, - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "https://foo.com/files/foo", - }, - }).Run(handler, t) + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) - (&httpTest{ - Name: "Filter forwarded protocol", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "X-Forwarded-Proto": "aaa", - "Forwarded": "proto=bbb", - }, - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "http://tus.io/files/foo", - }, - }).Run(handler, t) -} - -func TestPostWithUpload(t *testing.T) { - a := assert.New(t) - - handler, _ := NewHandler(Config{ - MaxSize: 400, - BasePath: "files", - DataStore: postStore{ - t: a, - }, - }) - - (&httpTest{ - Name: "Successful request", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Content-Type": "application/offset+octet-stream", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - }, - ReqBody: strings.NewReader("hello"), - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "http://tus.io/files/foo", - "Upload-Offset": "5", - }, - }).Run(handler, t) - - (&httpTest{ - Name: "Exceeding upload size", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Content-Type": "application/offset+octet-stream", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - }, - ReqBody: bytes.NewReader(make([]byte, 400)), - Code: http.StatusRequestEntityTooLarge, - }).Run(handler, t) - - (&httpTest{ - Name: "Incorrect content type", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "Content-Type": "application/false", - }, - ReqBody: strings.NewReader("hello"), - Code: http.StatusCreated, - ResHeader: map[string]string{ - "Location": "http://tus.io/files/foo", - "Upload-Offset": "", - }, - }).Run(handler, t) - - (&httpTest{ - Name: "Upload and final concatenation", - Method: "POST", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - "Upload-Length": "300", - "Content-Type": "application/offset+octet-stream", - "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", - "Upload-Concat": "final; http://tus.io/files/a http://tus.io/files/b", - }, - ReqBody: strings.NewReader("hello"), - Code: http.StatusForbidden, - }).Run(handler, t) + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "X-Forwarded-Host": "foo.com", + "X-Forwarded-Proto": "https", + }, + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "http://tus.io/files/foo", + }, + }).Run(handler, t) + }) + + SubTest(t, "RespectXForwarded", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + RespectForwardedHeaders: true, + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "X-Forwarded-Host": "foo.com", + "X-Forwarded-Proto": "https", + }, + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "https://foo.com/files/foo", + }, + }).Run(handler, t) + }) + + SubTest(t, "RespectForwarded", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + RespectForwardedHeaders: true, + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "X-Forwarded-Host": "bar.com", + "X-Forwarded-Proto": "http", + "Forwarded": "proto=https,host=foo.com", + }, + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "https://foo.com/files/foo", + }, + }).Run(handler, t) + }) + + SubTest(t, "FilterForwardedProtocol", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + RespectForwardedHeaders: true, + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "X-Forwarded-Proto": "aaa", + "Forwarded": "proto=bbb", + }, + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "http://tus.io/files/foo", + }, + }).Run(handler, t) + }) + }) + + SubTest(t, "WithUpload", func(t *testing.T, store *MockFullDataStore) { + SubTest(t, "Create", func(t *testing.T, store *MockFullDataStore) { + gomock.InOrder( + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{ + "foo": "hello", + "bar": "world", + }, + }).Return("foo", nil), + store.EXPECT().WriteChunk("foo", int64(0), NewReaderMatcher("hello")).Return(int64(5), nil), + ) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Content-Type": "application/offset+octet-stream", + "Upload-Metadata": "foo aGVsbG8=, bar d29ybGQ=", + }, + ReqBody: strings.NewReader("hello"), + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "http://tus.io/files/foo", + "Upload-Offset": "5", + }, + }).Run(handler, t) + }) + + SubTest(t, "CreateExceedingUploadSize", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Content-Type": "application/offset+octet-stream", + }, + ReqBody: bytes.NewReader(make([]byte, 400)), + Code: http.StatusRequestEntityTooLarge, + }).Run(handler, t) + }) + + SubTest(t, "IncorrectContentType", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().NewUpload(FileInfo{ + Size: 300, + MetaData: map[string]string{}, + }).Return("foo", nil) + + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) + + (&httpTest{ + Name: "Incorrect content type", + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Content-Type": "application/false", + }, + ReqBody: strings.NewReader("hello"), + Code: http.StatusCreated, + ResHeader: map[string]string{ + "Location": "http://tus.io/files/foo", + "Upload-Offset": "", + }, + }).Run(handler, t) + }) + + SubTest(t, "UploadToFinalUpload", func(t *testing.T, store *MockFullDataStore) { + handler, _ := NewHandler(Config{ + DataStore: store, + BasePath: "/files/", + }) + + (&httpTest{ + Method: "POST", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + "Upload-Length": "300", + "Content-Type": "application/offset+octet-stream", + "Upload-Concat": "final; http://tus.io/files/a http://tus.io/files/b", + }, + ReqBody: strings.NewReader("hello"), + Code: http.StatusForbidden, + }).Run(handler, t) + }) + }) } diff --git a/terminate_test.go b/terminate_test.go index 55b6293..91f9294 100644 --- a/terminate_test.go +++ b/terminate_test.go @@ -9,75 +9,71 @@ import ( "github.com/stretchr/testify/assert" ) -type terminateStore struct { - t *testing.T - zeroStore -} - -func (s terminateStore) GetInfo(id string) (FileInfo, error) { - return FileInfo{ - ID: id, - Size: 10, - }, nil -} - -func (s terminateStore) Terminate(id string) error { - if id != "foo" { - s.t.Fatal("unexpected id") - } - return nil -} - func TestTerminate(t *testing.T) { - handler, _ := NewHandler(Config{ - DataStore: terminateStore{ - t: t, - }, - NotifyTerminatedUploads: true, + SubTest(t, "ExtensionDiscovery", func(t *testing.T, store *MockFullDataStore) { + composer := NewStoreComposer() + composer.UseCore(store) + composer.UseTerminater(store) + + handler, _ := NewHandler(Config{ + StoreComposer: composer, + }) + + (&httpTest{ + Method: "OPTIONS", + Code: http.StatusOK, + ResHeader: map[string]string{ + "Tus-Extension": "creation,creation-with-upload,termination", + }, + }).Run(handler, t) }) - c := make(chan FileInfo, 1) - handler.TerminatedUploads = c + SubTest(t, "Termination", func(t *testing.T, store *MockFullDataStore) { + store.EXPECT().GetInfo("foo").Return(FileInfo{ + ID: "foo", + Size: 10, + }, nil) + store.EXPECT().Terminate("foo").Return(nil) - (&httpTest{ - Name: "Successful OPTIONS request", - Method: "OPTIONS", - URL: "", - ResHeader: map[string]string{ - "Tus-Extension": "creation,creation-with-upload,termination", - }, - Code: http.StatusOK, - }).Run(handler, t) + handler, _ := NewHandler(Config{ + DataStore: store, + NotifyTerminatedUploads: true, + }) - (&httpTest{ - Name: "Successful request", - Method: "DELETE", - URL: "foo", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusNoContent, - }).Run(handler, t) + c := make(chan FileInfo, 1) + handler.TerminatedUploads = c - info := <-c + (&httpTest{ + Method: "DELETE", + URL: "foo", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusNoContent, + }).Run(handler, t) - a := assert.New(t) - a.Equal("foo", info.ID) - a.Equal(int64(10), info.Size) -} + info := <-c -func TestTerminateNotImplemented(t *testing.T) { - handler, _ := NewHandler(Config{ - DataStore: zeroStore{}, + a := assert.New(t) + a.Equal("foo", info.ID) + a.Equal(int64(10), info.Size) }) - (&httpTest{ - Name: "TerminaterDataStore not implemented", - Method: "DELETE", - URL: "foo", - ReqHeader: map[string]string{ - "Tus-Resumable": "1.0.0", - }, - Code: http.StatusMethodNotAllowed, - }).Run(handler, t) + SubTest(t, "NotProvided", func(t *testing.T, store *MockFullDataStore) { + composer := NewStoreComposer() + composer.UseCore(store) + + handler, _ := NewHandler(Config{ + StoreComposer: composer, + }) + + (&httpTest{ + Method: "DELETE", + URL: "foo", + ReqHeader: map[string]string{ + "Tus-Resumable": "1.0.0", + }, + Code: http.StatusMethodNotAllowed, + }).Run(handler, t) + }) }