From 34853a01aa2a7c655c4baccd309bd55edbfb0544 Mon Sep 17 00:00:00 2001 From: Hiroto Funakoshi Date: Thu, 24 Sep 2020 14:20:28 +0900 Subject: [PATCH] :white_check_makr: :recycle: Add test for s3/writer and Refactor. (#672) * feat: wrapper for s3 manager Signed-off-by: hlts2 * fix: refactor Signed-off-by: hlts2 * fix: s3 type Signed-off-by: hlts2 * fix typo Signed-off-by: hlts2 * fix: apply suggestion Signed-off-by: hlts2 * add test for writer Signed-off-by: hlts2 * delete unncessary file Signed-off-by: hlts2 * delete unncessary code Signed-off-by: hlts2 * fix: apply feedback Signed-off-by: hlts2 * fix: add comment Signed-off-by: hlts2 * fix: fatal error Signed-off-by: hlts2 * fix: fatal error Signed-off-by: hlts2 * fix: fatal error Signed-off-by: hlts2 * fix: fatal error Signed-off-by: hlts2 * fix: apply suggestion Signed-off-by: hlts2 * fix: apply suggestion Signed-off-by: hlts2 * :robot: Update license headers / Format go codes and yaml files Signed-off-by: vdaas-ci Co-authored-by: vdaas-ci --- internal/db/storage/blob/s3/sdk/s3/s3.go | 23 + .../storage/blob/s3/sdk/s3/s3iface/s3iface.go | 21 + .../blob/s3/sdk/s3/s3manager/s3manager.go | 53 ++ .../db/storage/blob/s3/writer/mock_test.go | 54 ++ internal/db/storage/blob/s3/writer/writer.go | 27 +- .../db/storage/blob/s3/writer/writer_test.go | 467 ++++++++++-------- .../controller/handler/grpc/handler.go | 2 +- .../controller/handler/grpc/handler_test.go | 6 +- .../controller/handler/rest/handler.go | 2 +- .../controller/handler/rest/handler_test.go | 2 +- .../controller/handler/rest/option.go | 2 +- .../controller/handler/rest/option_test.go | 2 +- .../controller/usecase/discovered.go | 2 +- 13 files changed, 437 insertions(+), 226 deletions(-) create mode 100644 internal/db/storage/blob/s3/sdk/s3/s3.go create mode 100644 internal/db/storage/blob/s3/sdk/s3/s3iface/s3iface.go create mode 100644 internal/db/storage/blob/s3/sdk/s3/s3manager/s3manager.go create mode 100644 internal/db/storage/blob/s3/writer/mock_test.go diff --git a/internal/db/storage/blob/s3/sdk/s3/s3.go b/internal/db/storage/blob/s3/sdk/s3/s3.go new file mode 100644 index 0000000000..3c6f6312e2 --- /dev/null +++ b/internal/db/storage/blob/s3/sdk/s3/s3.go @@ -0,0 +1,23 @@ +// +// Copyright (C) 2019-2020 Vdaas.org Vald team ( kpango, rinx, kmrmt ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +package s3 + +import ( + "github.com/aws/aws-sdk-go/service/s3" +) + +// S3 is type alias for s3.S3. +type S3 = s3.S3 diff --git a/internal/db/storage/blob/s3/sdk/s3/s3iface/s3iface.go b/internal/db/storage/blob/s3/sdk/s3/s3iface/s3iface.go new file mode 100644 index 0000000000..700fb5c5ba --- /dev/null +++ b/internal/db/storage/blob/s3/sdk/s3/s3iface/s3iface.go @@ -0,0 +1,21 @@ +// +// Copyright (C) 2019-2020 Vdaas.org Vald team ( kpango, rinx, kmrmt ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +package s3iface + +import "github.com/aws/aws-sdk-go/service/s3/s3iface" + +// S3API is type alias for s3iface.S3API. +type S3API = s3iface.S3API diff --git a/internal/db/storage/blob/s3/sdk/s3/s3manager/s3manager.go b/internal/db/storage/blob/s3/sdk/s3/s3manager/s3manager.go new file mode 100644 index 0000000000..34e80db9a9 --- /dev/null +++ b/internal/db/storage/blob/s3/sdk/s3/s3manager/s3manager.go @@ -0,0 +1,53 @@ +// +// Copyright (C) 2019-2020 Vdaas.org Vald team ( kpango, rinx, kmrmt ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +package s3manager + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/s3/s3manager" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3iface" +) + +type ( + // Uploader is type alias of s3manager.Uploader. + Uploader = s3manager.Uploader + // UploadInput is type alias of s3manager.UploadInput. + UploadInput = s3manager.UploadInput + // UploadOutput is type alias of s3manager.UploadOutput. + UploadOutput = s3manager.UploadOutput +) + +// UploadClient represents an interface to upload to s3. +type UploadClient interface { + UploadWithContext(ctx aws.Context, input *UploadInput, opts ...func(*Uploader)) (*UploadOutput, error) +} + +// S3Manager represents an interface to create object of s3manager package. +type S3Manager interface { + NewUploaderWithClient(svc s3iface.S3API, options ...func(*Uploader)) UploadClient +} + +type s3mngr struct{} + +// New returns S3Manager implementation. +func New() S3Manager { + return new(s3mngr) +} + +// NewUploaderWithClient returns UploadClient implementation. +func (*s3mngr) NewUploaderWithClient(svc s3iface.S3API, options ...func(*Uploader)) UploadClient { + return s3manager.NewUploaderWithClient(svc, options...) +} diff --git a/internal/db/storage/blob/s3/writer/mock_test.go b/internal/db/storage/blob/s3/writer/mock_test.go new file mode 100644 index 0000000000..9b357167ba --- /dev/null +++ b/internal/db/storage/blob/s3/writer/mock_test.go @@ -0,0 +1,54 @@ +// +// Copyright (C) 2019-2020 Vdaas.org Vald team ( kpango, rinx, kmrmt ) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +package writer + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3iface" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3manager" +) + +// S3Manager represents mock of s3manager.S3Manager. +type MockS3Manager struct { + NewUploaderWithClientFunc func(s3iface.S3API, ...func(*s3manager.Uploader)) s3manager.UploadClient +} + +// NewUploaderWithClient calls NewUNewUploaderWithClientFunc. +func (m *MockS3Manager) NewUploaderWithClient(svc s3iface.S3API, opts ...func(*s3manager.Uploader)) s3manager.UploadClient { + return m.NewUploaderWithClientFunc(svc, opts...) +} + +type MockUploadClient struct { + UploadWithContextFunc func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) +} + +func (m *MockUploadClient) UploadWithContext(ctx aws.Context, input *s3manager.UploadInput, opts ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { + return m.UploadWithContextFunc(ctx, input, opts...) +} + +// MockWriteCloser represents mock of io.WriteCloser. +type MockWriteCloser struct { + WriteFunc func(p []byte) (n int, err error) + CloseFunc func() error +} + +func (m *MockWriteCloser) Write(p []byte) (n int, err error) { + return m.WriteFunc(p) +} + +func (m *MockWriteCloser) Close() error { + return m.CloseFunc() +} diff --git a/internal/db/storage/blob/s3/writer/writer.go b/internal/db/storage/blob/s3/writer/writer.go index 805814aeda..d048f77df2 100644 --- a/internal/db/storage/blob/s3/writer/writer.go +++ b/internal/db/storage/blob/s3/writer/writer.go @@ -23,8 +23,8 @@ import ( "sync" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/s3" - "github.com/aws/aws-sdk-go/service/s3/s3manager" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3iface" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3manager" "github.com/vdaas/vald/internal/errgroup" "github.com/vdaas/vald/internal/errors" "github.com/vdaas/vald/internal/log" @@ -32,10 +32,11 @@ import ( ) type writer struct { - eg errgroup.Group - service *s3.S3 - bucket string - key string + eg errgroup.Group + s3manager s3manager.S3Manager + service s3iface.S3API + bucket string + key string contentType string maxPartSize int64 @@ -44,13 +45,17 @@ type writer struct { wg *sync.WaitGroup } +// Writer represents an interface to write to s3. type Writer interface { Open(ctx context.Context) error io.WriteCloser } +// New returns Writer implementation. func New(opts ...Option) Writer { - w := new(writer) + w := &writer{ + s3manager: s3manager.New(), + } for _, opt := range append(defaultOpts, opts...) { if err := opt(w); err != nil { log.Warn(errors.ErrOptionFailed(err, reflect.ValueOf(opt))) @@ -60,6 +65,8 @@ func New(opts ...Option) Writer { return w } +// Open creates io.Pipe. When the write method is called, the written data will be uploaded to s3. +// Open method returns an error to align the interface, but it doesn't actually return an error. func (w *writer) Open(ctx context.Context) (err error) { w.wg = new(sync.WaitGroup) @@ -79,6 +86,7 @@ func (w *writer) Open(ctx context.Context) (err error) { return err } +// Close closes the writer. func (w *writer) Close() error { if w.pw != nil { return w.pw.Close() @@ -91,6 +99,7 @@ func (w *writer) Close() error { return nil } +// Write writes len(p) bytes from p to the underlying data stream. The written data will be uploaded to s3. func (w *writer) Write(p []byte) (n int, err error) { if w.pw == nil { return 0, errors.ErrStorageWriterNotOpened @@ -100,7 +109,7 @@ func (w *writer) Write(p []byte) (n int, err error) { } func (w *writer) upload(ctx context.Context, body io.Reader) (err error) { - uploader := s3manager.NewUploaderWithClient( + client := w.s3manager.NewUploaderWithClient( w.service, func(u *s3manager.Uploader) { u.PartSize = w.maxPartSize @@ -113,7 +122,7 @@ func (w *writer) upload(ctx context.Context, body io.Reader) (err error) { ContentType: aws.String(w.contentType), } - res, err := uploader.UploadWithContext(ctx, input) + res, err := client.UploadWithContext(ctx, input) if err != nil { log.Error("upload failed with error: ", err) return err diff --git a/internal/db/storage/blob/s3/writer/writer_test.go b/internal/db/storage/blob/s3/writer/writer_test.go index 526b0f2c5c..913398af97 100644 --- a/internal/db/storage/blob/s3/writer/writer_test.go +++ b/internal/db/storage/blob/s3/writer/writer_test.go @@ -19,16 +19,26 @@ package writer import ( "context" "io" + "os" "reflect" "sync" "testing" + "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/s3" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3iface" + "github.com/vdaas/vald/internal/db/storage/blob/s3/sdk/s3/s3manager" "github.com/vdaas/vald/internal/errgroup" "github.com/vdaas/vald/internal/errors" + "github.com/vdaas/vald/internal/log" "go.uber.org/goleak" ) +func TestMain(m *testing.M) { + log.Init() + os.Exit(m.Run()) +} + func TestNew(t *testing.T) { type args struct { opts []Option @@ -51,36 +61,61 @@ func TestNew(t *testing.T) { return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - opts: nil, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - opts: nil, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns writer when option is empty", + args: args{ + opts: nil, + }, + want: want{ + want: &writer{ + eg: errgroup.Get(), + contentType: "application/octet-stream", + maxPartSize: 64 * 1024 * 1024, + s3manager: s3manager.New(), + }, + }, + }, + + { + name: "returns writer when option is not empty", + args: args{ + opts: []Option{ + WithContentType("vdaas"), + }, + }, + want: want{ + want: &writer{ + eg: errgroup.Get(), + contentType: "vdaas", + maxPartSize: 64 * 1024 * 1024, + s3manager: s3manager.New(), + }, + }, + }, + + { + name: "returns writer and outputs the warn when option is not empty and option apply fails", + args: args{ + opts: []Option{ + func(w *writer) error { + return errors.New("err") + }, + }, + }, + want: want{ + want: &writer{ + eg: errgroup.Get(), + contentType: "application/octet-stream", + maxPartSize: 64 * 1024 * 1024, + s3manager: s3manager.New(), + }, + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(tt) + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) if test.beforeFunc != nil { test.beforeFunc(test.args) } @@ -95,7 +130,6 @@ func TestNew(t *testing.T) { if err := test.checkFunc(test.want, got); err != nil { tt.Errorf("error = %v", err) } - }) } } @@ -106,6 +140,7 @@ func Test_writer_Open(t *testing.T) { } type fields struct { eg errgroup.Group + s3manager s3manager.S3Manager service *s3.S3 bucket string key string @@ -132,54 +167,34 @@ func Test_writer_Open(t *testing.T) { return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - ctx: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - ctx: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns nil when no error occurs", + args: args{ + ctx: nil, + }, + fields: fields{ + eg: errgroup.Get(), + s3manager: &MockS3Manager{ + NewUploaderWithClientFunc: func(s3iface.S3API, ...func(*s3manager.Uploader)) s3manager.UploadClient { + return &MockUploadClient{ + UploadWithContextFunc: func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { + return &s3manager.UploadOutput{ + Location: "location", + }, nil + }, + } + }, + }, + }, + want: want{ + err: nil, + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(tt) + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) if test.beforeFunc != nil { test.beforeFunc(test.args) } @@ -191,6 +206,7 @@ func Test_writer_Open(t *testing.T) { } w := &writer{ eg: test.fields.eg, + s3manager: test.fields.s3manager, service: test.fields.service, bucket: test.fields.bucket, key: test.fields.key, @@ -236,48 +252,49 @@ func Test_writer_Close(t *testing.T) { return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns nil when no error occurs", + fields: fields{ + pw: &MockWriteCloser{ + CloseFunc: func() error { + return nil + }, + }, + wg: new(sync.WaitGroup), + }, + want: want{ + err: nil, + }, + }, + + { + name: "returns error when close error occurs", + fields: fields{ + pw: &MockWriteCloser{ + CloseFunc: func() error { + return errors.New("err") + }, + }, + }, + want: want{ + err: errors.New("err"), + }, + }, + + { + name: "returns nil when no error occurs and writer dose not exist", + fields: fields{ + wg: new(sync.WaitGroup), + }, + want: want{ + err: nil, + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(tt) + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) if test.beforeFunc != nil { test.beforeFunc() } @@ -342,54 +359,58 @@ func Test_writer_Write(t *testing.T) { return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - p: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - p: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns nil When the write success", + args: args{ + p: []byte{}, + }, + fields: fields{ + pw: &MockWriteCloser{ + WriteFunc: func(p []byte) (n int, err error) { + return 10, nil + }, + }, + }, + want: want{ + wantN: 10, + err: nil, + }, + }, + + { + name: "returns error When there is no writer", + args: args{ + p: []byte{}, + }, + fields: fields{ + pw: nil, + }, + want: want{ + err: errors.ErrStorageWriterNotOpened, + }, + }, + + { + name: "returns error When the write fails", + args: args{ + p: []byte{}, + }, + fields: fields{ + pw: &MockWriteCloser{ + WriteFunc: func(p []byte) (n int, err error) { + return 0, errors.New("err") + }, + }, + }, + want: want{ + err: errors.New("err"), + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(tt) + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) if test.beforeFunc != nil { test.beforeFunc(test.args) } @@ -425,6 +446,7 @@ func Test_writer_upload(t *testing.T) { } type fields struct { eg errgroup.Group + s3manager s3manager.S3Manager service *s3.S3 bucket string key string @@ -438,7 +460,7 @@ func Test_writer_upload(t *testing.T) { type test struct { name string args args - fields fields + fieldsFunc func(*testing.T) fields want want checkFunc func(want, error) error beforeFunc func(args) @@ -451,56 +473,82 @@ func Test_writer_upload(t *testing.T) { return nil } tests := []test{ - // TODO test cases - /* - { - name: "test_case_1", - args: args { - ctx: nil, - body: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - }, - */ - - // TODO test cases - /* - func() test { - return test { - name: "test_case_2", - args: args { - ctx: nil, - body: nil, - }, - fields: fields { - eg: nil, - service: nil, - bucket: "", - key: "", - maxPartSize: 0, - pw: nil, - wg: sync.WaitGroup{}, - }, - want: want{}, - checkFunc: defaultCheckFunc, - } - }(), - */ + { + name: "returns nil when no error occurs", + args: args{ + ctx: context.Background(), + body: nil, + }, + fieldsFunc: func(t *testing.T) fields { + t.Helper() + return fields{ + s3manager: &MockS3Manager{ + NewUploaderWithClientFunc: func(_ s3iface.S3API, opts ...func(*s3manager.Uploader)) s3manager.UploadClient { + u := new(s3manager.Uploader) + for _, opt := range opts { + opt(u) + } + + if !reflect.DeepEqual(u.PartSize, int64(100)) { + t.Errorf("PartSize is invalid. want: %v, but got: %v", 100, u.PartSize) + } + + return &MockUploadClient{ + UploadWithContextFunc: func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { + return &s3manager.UploadOutput{ + Location: "location", + }, nil + }, + } + }, + }, + maxPartSize: 100, + } + }, + want: want{ + err: nil, + }, + }, + + { + name: "returns error when upload fails", + args: args{ + ctx: context.Background(), + body: nil, + }, + fieldsFunc: func(t *testing.T) fields { + t.Helper() + return fields{ + s3manager: &MockS3Manager{ + NewUploaderWithClientFunc: func(_ s3iface.S3API, opts ...func(*s3manager.Uploader)) s3manager.UploadClient { + u := new(s3manager.Uploader) + for _, opt := range opts { + opt(u) + } + + if !reflect.DeepEqual(u.PartSize, int64(100)) { + t.Errorf("PartSize is invalid. want: %v, but got: %v", 100, u.PartSize) + } + + return &MockUploadClient{ + UploadWithContextFunc: func(aws.Context, *s3manager.UploadInput, ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { + return nil, errors.New("err") + }, + } + }, + }, + maxPartSize: 100, + } + }, + want: want{ + err: errors.New("err"), + }, + }, } for _, test := range tests { t.Run(test.name, func(tt *testing.T) { - defer goleak.VerifyNone(tt) + defer goleak.VerifyNone(tt, goleakIgnoreOptions...) if test.beforeFunc != nil { test.beforeFunc(test.args) } @@ -510,21 +558,24 @@ func Test_writer_upload(t *testing.T) { if test.checkFunc == nil { test.checkFunc = defaultCheckFunc } + + fields := test.fieldsFunc(t) + w := &writer{ - eg: test.fields.eg, - service: test.fields.service, - bucket: test.fields.bucket, - key: test.fields.key, - maxPartSize: test.fields.maxPartSize, - pw: test.fields.pw, - wg: test.fields.wg, + eg: fields.eg, + s3manager: fields.s3manager, + service: fields.service, + bucket: fields.bucket, + key: fields.key, + maxPartSize: fields.maxPartSize, + pw: fields.pw, + wg: fields.wg, } err := w.upload(test.args.ctx, test.args.body) if err := test.checkFunc(test.want, err); err != nil { tt.Errorf("error = %v", err) } - }) } } diff --git a/pkg/manager/replication/controller/handler/grpc/handler.go b/pkg/manager/replication/controller/handler/grpc/handler.go index fa215e2fd1..5cbd4a8ac1 100644 --- a/pkg/manager/replication/controller/handler/grpc/handler.go +++ b/pkg/manager/replication/controller/handler/grpc/handler.go @@ -29,7 +29,7 @@ type server struct { controller service.Replicator } -func New(opts ...Option) controller.ReplicationServer { +func New(opts ...Option) controller.ReplicationControllerServer { s := new(server) for _, opt := range append(defaultOpts, opts...) { diff --git a/pkg/manager/replication/controller/handler/grpc/handler_test.go b/pkg/manager/replication/controller/handler/grpc/handler_test.go index 34d89ad8b0..30e5dbe4c0 100644 --- a/pkg/manager/replication/controller/handler/grpc/handler_test.go +++ b/pkg/manager/replication/controller/handler/grpc/handler_test.go @@ -35,17 +35,17 @@ func TestNew(t *testing.T) { opts []Option } type want struct { - want controller.ReplicationServer + want controller.ReplicationControllerServer } type test struct { name string args args want want - checkFunc func(want, controller.ReplicationServer) error + checkFunc func(want, controller.ReplicationControllerServer) error beforeFunc func(args) afterFunc func(args) } - defaultCheckFunc := func(w want, got controller.ReplicationServer) error { + defaultCheckFunc := func(w want, got controller.ReplicationControllerServer) error { if !reflect.DeepEqual(got, w.want) { return errors.Errorf("got: \"%#v\",\n\t\t\t\twant: \"%#v\"", got, w.want) } diff --git a/pkg/manager/replication/controller/handler/rest/handler.go b/pkg/manager/replication/controller/handler/rest/handler.go index bd31188d5d..fb1abf481e 100644 --- a/pkg/manager/replication/controller/handler/rest/handler.go +++ b/pkg/manager/replication/controller/handler/rest/handler.go @@ -30,7 +30,7 @@ type Handler interface { } type handler struct { - rpl controller.ReplicationServer + rpl controller.ReplicationControllerServer } func New(opts ...Option) Handler { diff --git a/pkg/manager/replication/controller/handler/rest/handler_test.go b/pkg/manager/replication/controller/handler/rest/handler_test.go index b687f22cf7..ca173ba6b4 100644 --- a/pkg/manager/replication/controller/handler/rest/handler_test.go +++ b/pkg/manager/replication/controller/handler/rest/handler_test.go @@ -105,7 +105,7 @@ func Test_handler_Index(t *testing.T) { r *http.Request } type fields struct { - rpl controller.ReplicationServer + rpl controller.ReplicationControllerServer } type want struct { want int diff --git a/pkg/manager/replication/controller/handler/rest/option.go b/pkg/manager/replication/controller/handler/rest/option.go index d62b0716f7..c1996d13e3 100644 --- a/pkg/manager/replication/controller/handler/rest/option.go +++ b/pkg/manager/replication/controller/handler/rest/option.go @@ -27,7 +27,7 @@ var ( defaultOpts = []Option{} ) -func WithReplicator(rpl controller.ReplicationServer) Option { +func WithReplicator(rpl controller.ReplicationControllerServer) Option { return func(h *handler) { if rpl != nil { h.rpl = rpl diff --git a/pkg/manager/replication/controller/handler/rest/option_test.go b/pkg/manager/replication/controller/handler/rest/option_test.go index 9cf255ed70..1af654f20b 100644 --- a/pkg/manager/replication/controller/handler/rest/option_test.go +++ b/pkg/manager/replication/controller/handler/rest/option_test.go @@ -28,7 +28,7 @@ import ( func TestWithReplicator(t *testing.T) { type T = interface{} type args struct { - rpl controller.ReplicationServer + rpl controller.ReplicationControllerServer } type want struct { obj *T diff --git a/pkg/manager/replication/controller/usecase/discovered.go b/pkg/manager/replication/controller/usecase/discovered.go index 4721bb0b86..93e29d1c32 100644 --- a/pkg/manager/replication/controller/usecase/discovered.go +++ b/pkg/manager/replication/controller/usecase/discovered.go @@ -57,7 +57,7 @@ func New(cfg *config.Data) (r runner.Runner, err error) { grpcServerOptions := []server.Option{ server.WithGRPCRegistFunc(func(srv *grpc.Server) { - controller.RegisterReplicationServer(srv, g) + controller.RegisterReplicationControllerServer(srv, g) }), server.WithGRPCOption( grpc.ChainUnaryInterceptor(grpc.RecoverInterceptor()),