From 784f05fb735daa7af30e59518996682e3255fda7 Mon Sep 17 00:00:00 2001 From: Adam Haffar <110104037+AdamHaffar@users.noreply.github.com> Date: Thu, 31 Aug 2023 12:59:45 +0100 Subject: [PATCH] Remove Assert Package 1/3 (#1177) --- pkg/conduit/config_test.go | 8 +- pkg/pipeline/store_test.go | 27 +-- pkg/pipeline/stream/base_test.go | 212 +++++++++++---------- pkg/pipeline/stream/message_test.go | 11 +- pkg/pipeline/stream/processor_test.go | 32 ++-- pkg/record/schema/acceptance_testing.go | 42 +++-- pkg/record/schema/proto/mutable_test.go | 240 ++++++++++++++---------- pkg/record/schema/proto/schema_test.go | 178 ++++++++++-------- pkg/web/api/connector_v1_test.go | 67 ++++--- pkg/web/api/plugin_v1_test.go | 8 +- pkg/web/api/processor_v1_test.go | 57 ++++-- pkg/web/api/status/status_test.go | 18 +- 12 files changed, 532 insertions(+), 368 deletions(-) diff --git a/pkg/conduit/config_test.go b/pkg/conduit/config_test.go index 1ad8af874..156c9ffac 100644 --- a/pkg/conduit/config_test.go +++ b/pkg/conduit/config_test.go @@ -17,11 +17,13 @@ package conduit import ( "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/database/inmemory" + "github.com/matryer/is" ) func TestConfig_Validate(t *testing.T) { + is := is.New(t) + testCases := []struct { name string setupConfig func(Config) Config @@ -162,9 +164,9 @@ func TestConfig_Validate(t *testing.T) { underTest := tc.setupConfig(validConfig) got := underTest.Validate() if got == nil { - assert.Nil(t, tc.want) + is.True(tc.want == nil) } else { - assert.Equal(t, tc.want.Error(), got.Error()) + is.Equal(tc.want.Error(), got.Error()) } }) } diff --git a/pkg/pipeline/store_test.go b/pkg/pipeline/store_test.go index ee2a9f446..10f9bbcad 100644 --- a/pkg/pipeline/store_test.go +++ b/pkg/pipeline/store_test.go @@ -19,11 +19,11 @@ import ( "fmt" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/foundation/database" "github.com/conduitio/conduit/pkg/foundation/database/inmemory" "github.com/google/uuid" + "github.com/matryer/is" ) type boringError struct { @@ -63,6 +63,7 @@ func TestConfigStore_SetGet(t *testing.T) { } func testConfigStoreSetGet(t *testing.T, e error) { + is := is.New(t) ctx := context.Background() db := &inmemory.DB{} @@ -81,14 +82,15 @@ func testConfigStoreSetGet(t *testing.T, e error) { } err := s.Set(ctx, want.ID, want) - assert.Ok(t, err) + is.NoErr(err) got, err := s.Get(ctx, want.ID) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestConfigStore_GetAll(t *testing.T) { + is := is.New(t) ctx := context.Background() db := &inmemory.DB{} @@ -106,16 +108,17 @@ func TestConfigStore_GetAll(t *testing.T) { ProcessorIDs: []string{uuid.NewString(), uuid.NewString()}, } err := s.Set(ctx, instance.ID, instance) - assert.Ok(t, err) + is.NoErr(err) want[instance.ID] = instance } got, err := s.GetAll(ctx) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestConfigStore_Delete(t *testing.T) { + is := is.New(t) ctx := context.Background() db := &inmemory.DB{} @@ -124,13 +127,13 @@ func TestConfigStore_Delete(t *testing.T) { want := &Instance{ID: uuid.NewString()} err := s.Set(ctx, want.ID, want) - assert.Ok(t, err) + is.NoErr(err) err = s.Delete(ctx, want.ID) - assert.Ok(t, err) + is.NoErr(err) got, err := s.Get(ctx, want.ID) - assert.Error(t, err) - assert.True(t, cerrors.Is(err, database.ErrKeyNotExist), "expected error for non-existing key") - assert.Nil(t, got) + is.True(err != nil) + is.True(cerrors.Is(err, database.ErrKeyNotExist)) // expected error for non-existing key + is.True(got == nil) } diff --git a/pkg/pipeline/stream/base_test.go b/pkg/pipeline/stream/base_test.go index 97a3d86ab..7430eb59c 100644 --- a/pkg/pipeline/stream/base_test.go +++ b/pkg/pipeline/stream/base_test.go @@ -19,57 +19,61 @@ import ( "testing" "time" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/foundation/log" + "github.com/matryer/is" ) func TestPubSubNodeBase_TriggerWithoutPubOrSub(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() n := &pubSubNodeBase{} trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) n = &pubSubNodeBase{} n.Pub() trigger, cleanup, err = n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) n = &pubSubNodeBase{} n.Sub(make(chan *Message)) trigger, cleanup, err = n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestPubSubNodeBase_PubTwice(t *testing.T) { + is := is.New(t) n := &pubSubNodeBase{} n.Pub() // first one succeeds defer func() { - assert.NotNil(t, recover()) + is.True(recover() != nil) }() n.Pub() // second one should panic } func TestPubSubNodeBase_SubTwice(t *testing.T) { + is := is.New(t) n := &pubSubNodeBase{} n.Sub(make(chan *Message)) // first one succeeds defer func() { - assert.NotNil(t, recover()) + is.True(recover() != nil) }() n.Sub(make(chan *Message)) // second one should panic } func TestPubSubNodeBase_TriggerTwice(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -77,17 +81,18 @@ func TestPubSubNodeBase_TriggerTwice(t *testing.T) { n.Pub() n.Sub(make(chan *Message)) trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) trigger, cleanup, err = n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestPubSubNodeBase_TriggerSuccess(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -97,9 +102,9 @@ func TestPubSubNodeBase_TriggerSuccess(t *testing.T) { n.Pub() trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -110,11 +115,12 @@ func TestPubSubNodeBase_TriggerSuccess(t *testing.T) { }() got, err := trigger() - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestPubSubNodeBase_TriggerClosedSubChannel(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -124,9 +130,9 @@ func TestPubSubNodeBase_TriggerClosedSubChannel(t *testing.T) { n.Pub() trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -134,11 +140,12 @@ func TestPubSubNodeBase_TriggerClosedSubChannel(t *testing.T) { close(in) got, err := trigger() - assert.Ok(t, err) - assert.Nil(t, got) + is.NoErr(err) + is.True(got == nil) } func TestPubSubNodeBase_TriggerCancelledContext(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithCancel(context.Background()) logger := log.Nop() @@ -148,9 +155,9 @@ func TestPubSubNodeBase_TriggerCancelledContext(t *testing.T) { n.Pub() trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -158,11 +165,12 @@ func TestPubSubNodeBase_TriggerCancelledContext(t *testing.T) { cancel() got, err := trigger() - assert.Error(t, err) - assert.Nil(t, got) + is.True(err != nil) + is.True(got == nil) } func TestPubSubNodeBase_Send(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100) defer cancel() logger := log.Nop() @@ -173,18 +181,19 @@ func TestPubSubNodeBase_Send(t *testing.T) { want := &Message{} go func() { err := n.Send(ctx, logger, want) - assert.Ok(t, err) + is.NoErr(err) }() select { case <-ctx.Done(): t.Fatal("did not expect context to get canceled before receiving message") case got := <-out: - assert.Equal(t, want, got) + is.Equal(want, got) } } func TestPubSubNodeBase_SendCancelledContext(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithCancel(context.Background()) logger := log.Nop() @@ -195,7 +204,7 @@ func TestPubSubNodeBase_SendCancelledContext(t *testing.T) { cancel() // context is cancelled before sending the message go func() { err := n.Send(ctx, logger, msg) - assert.Error(t, err) + is.True(err != nil) }() time.Sleep(1 * time.Millisecond) // give runtime the ability to run the go routine @@ -209,44 +218,48 @@ func TestPubSubNodeBase_SendCancelledContext(t *testing.T) { } func TestPubNodeBase_TriggerWithoutPub(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() n := &pubNodeBase{} trigger, cleanup, err := n.Trigger(ctx, logger, nil, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestPubNodeBase_TriggerTwice(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() n := &pubNodeBase{} n.Pub() trigger, cleanup, err := n.Trigger(ctx, logger, nil, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) trigger, cleanup, err = n.Trigger(ctx, logger, nil, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestPubNodeBase_PubTwice(t *testing.T) { + is := is.New(t) n := &pubNodeBase{} n.Pub() // first one succeeds defer func() { - assert.NotNil(t, recover()) + is.True(recover() != nil) }() n.Pub() // second one should panic } func TestPubNodeBase_TriggerSuccess(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -262,18 +275,19 @@ func TestPubNodeBase_TriggerSuccess(t *testing.T) { return want, nil }, ) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() got, err := trigger() - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestPubNodeBase_TriggerWithErrorChan(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -282,9 +296,9 @@ func TestPubNodeBase_TriggerWithErrorChan(t *testing.T) { errChan := make(chan error, 1) // buffered channel to prevent locking trigger, cleanup, err := n.Trigger(ctx, logger, errChan, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -293,11 +307,12 @@ func TestPubNodeBase_TriggerWithErrorChan(t *testing.T) { errChan <- wantErr got, err := trigger() - assert.Nil(t, got) - assert.Equal(t, wantErr, err) + is.True(got == nil) + is.Equal(wantErr, err) } func TestPubNodeBase_TriggerCancelledContext(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithCancel(context.Background()) logger := log.Nop() @@ -305,9 +320,9 @@ func TestPubNodeBase_TriggerCancelledContext(t *testing.T) { n.Pub() trigger, cleanup, err := n.Trigger(ctx, logger, nil, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -315,11 +330,12 @@ func TestPubNodeBase_TriggerCancelledContext(t *testing.T) { cancel() got, err := trigger() - assert.Error(t, err) - assert.Nil(t, got) + is.True(err != nil) + is.True(got == nil) } func TestPubNodeBase_Send(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100) defer cancel() logger := log.Nop() @@ -330,18 +346,19 @@ func TestPubNodeBase_Send(t *testing.T) { want := &Message{} go func() { err := n.Send(ctx, logger, want) - assert.Ok(t, err) + is.NoErr(err) }() select { case <-ctx.Done(): t.Fatal("did not expect context to get cancelled before receiving message") case got := <-out: - assert.Equal(t, want, got) + is.Equal(want, got) } } func TestPubNodeBase_SendCancelledContext(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithCancel(context.Background()) logger := log.Nop() @@ -352,7 +369,7 @@ func TestPubNodeBase_SendCancelledContext(t *testing.T) { cancel() // context is cancelled before sending the message go func() { err := n.Send(ctx, logger, msg) - assert.Error(t, err) + is.True(err != nil) }() time.Sleep(1 * time.Millisecond) // give runtime the ability to run the go routine @@ -366,44 +383,48 @@ func TestPubNodeBase_SendCancelledContext(t *testing.T) { } func TestSubNodeBase_TriggerWithoutSub(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() n := &subNodeBase{} trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestSubNodeBase_TriggerTwice(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() n := &subNodeBase{} n.Sub(make(chan *Message)) trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) trigger, cleanup, err = n.Trigger(ctx, logger, nil) - assert.Nil(t, trigger) - assert.Nil(t, cleanup) - assert.Error(t, err) + is.True(trigger == nil) + is.True(cleanup == nil) + is.True(err != nil) } func TestSubNodeBase_SubTwice(t *testing.T) { + is := is.New(t) n := &subNodeBase{} n.Sub(make(chan *Message)) // first one succeeds defer func() { - assert.NotNil(t, recover()) + is.True(recover() != nil) }() n.Sub(make(chan *Message)) // second one should panic } func TestSubNodeBase_TriggerSuccess(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -412,9 +433,9 @@ func TestSubNodeBase_TriggerSuccess(t *testing.T) { n.Sub(in) trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -425,11 +446,12 @@ func TestSubNodeBase_TriggerSuccess(t *testing.T) { }() got, err := trigger() - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestSubNodeBase_TriggerClosedSubChannel(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -438,9 +460,9 @@ func TestSubNodeBase_TriggerClosedSubChannel(t *testing.T) { n.Sub(in) trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -448,11 +470,12 @@ func TestSubNodeBase_TriggerClosedSubChannel(t *testing.T) { close(in) got, err := trigger() - assert.Ok(t, err) - assert.Nil(t, got) + is.NoErr(err) + is.True(got == nil) } func TestSubNodeBase_TriggerWithErrorChan(t *testing.T) { + is := is.New(t) ctx := context.Background() logger := log.Nop() @@ -462,9 +485,9 @@ func TestSubNodeBase_TriggerWithErrorChan(t *testing.T) { errChan := make(chan error, 1) // buffered channel to prevent locking trigger, cleanup, err := n.Trigger(ctx, logger, errChan) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -473,11 +496,12 @@ func TestSubNodeBase_TriggerWithErrorChan(t *testing.T) { errChan <- wantErr got, err := trigger() - assert.Nil(t, got) - assert.Equal(t, wantErr, err) + is.True(got == nil) + is.Equal(wantErr, err) } func TestSubNodeBase_TriggerCancelledContext(t *testing.T) { + is := is.New(t) ctx, cancel := context.WithCancel(context.Background()) logger := log.Nop() @@ -486,9 +510,9 @@ func TestSubNodeBase_TriggerCancelledContext(t *testing.T) { n.Sub(in) trigger, cleanup, err := n.Trigger(ctx, logger, nil) - assert.Ok(t, err) - assert.NotNil(t, trigger) - assert.NotNil(t, cleanup) + is.NoErr(err) + is.True(trigger != nil) + is.True(cleanup != nil) defer cleanup() @@ -496,6 +520,6 @@ func TestSubNodeBase_TriggerCancelledContext(t *testing.T) { cancel() got, err := trigger() - assert.Error(t, err) - assert.Nil(t, got) + is.True(err != nil) + is.True(got == nil) } diff --git a/pkg/pipeline/stream/message_test.go b/pkg/pipeline/stream/message_test.go index affbce904..69b314e54 100644 --- a/pkg/pipeline/stream/message_test.go +++ b/pkg/pipeline/stream/message_test.go @@ -17,8 +17,8 @@ package stream import ( "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" + "github.com/matryer/is" ) func TestMessage_Ack_WithoutHandler(t *testing.T) { @@ -363,13 +363,16 @@ func TestMessage_RegisterHandlerFail(t *testing.T) { } func assertMessageIsAcked(t *testing.T, msg *Message) { - assert.Equal(t, MessageStatusAcked, msg.Status()) + is := is.New(t) + is.Equal(MessageStatusAcked, msg.Status()) } func assertMessageIsNacked(t *testing.T, msg *Message) { - assert.Equal(t, MessageStatusNacked, msg.Status()) + is := is.New(t) + is.Equal(MessageStatusNacked, msg.Status()) } func assertMessageIsOpen(t *testing.T, msg *Message) { - assert.Equal(t, MessageStatusOpen, msg.Status()) + is := is.New(t) + is.Equal(MessageStatusOpen, msg.Status()) } diff --git a/pkg/pipeline/stream/processor_test.go b/pkg/pipeline/stream/processor_test.go index 06cfc6ecd..10100668f 100644 --- a/pkg/pipeline/stream/processor_test.go +++ b/pkg/pipeline/stream/processor_test.go @@ -19,17 +19,18 @@ import ( "sync" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/foundation/metrics/noop" "github.com/conduitio/conduit/pkg/processor" "github.com/conduitio/conduit/pkg/processor/mock" "github.com/conduitio/conduit/pkg/record" "github.com/google/uuid" + "github.com/matryer/is" "go.uber.org/mock/gomock" ) func TestProcessorNode_Success(t *testing.T) { + is := is.New(t) ctx := context.Background() ctrl := gomock.NewController(t) @@ -71,7 +72,7 @@ func TestProcessorNode_Success(t *testing.T) { go func() { defer wg.Done() err := n.Run(ctx) - assert.Ok(t, err) + is.NoErr(err) }() got := <-out @@ -80,16 +81,17 @@ func TestProcessorNode_Success(t *testing.T) { Record: wantRec, } wantMsg.Record.Position = newPosition // position was transformed - assert.Equal(t, wantMsg, got) + is.Equal(wantMsg, got) wg.Wait() // wait for node to stop running // after the node stops the out channel should be closed _, ok := <-out - assert.Equal(t, false, ok) + is.Equal(false, ok) } func TestProcessorNode_ErrorWithoutNackHandler(t *testing.T) { + is := is.New(t) ctx := context.Background() ctrl := gomock.NewController(t) @@ -115,14 +117,15 @@ func TestProcessorNode_ErrorWithoutNackHandler(t *testing.T) { }() err := n.Run(ctx) - assert.True(t, cerrors.Is(err, wantErr), "expected underlying error to be the processor error") + is.True(cerrors.Is(err, wantErr)) // expected underlying error to be the processor error // after the node stops the out channel should be closed _, ok := <-out - assert.Equal(t, false, ok) + is.Equal(false, ok) } func TestProcessorNode_ErrorWithNackHandler(t *testing.T) { + is := is.New(t) ctx := context.Background() ctrl := gomock.NewController(t) @@ -142,8 +145,8 @@ func TestProcessorNode_ErrorWithNackHandler(t *testing.T) { msg := &Message{Ctx: ctx} msg.RegisterNackHandler(func(msg *Message, nackMetadata NackMetadata) error { - assert.True(t, cerrors.Is(nackMetadata.Reason, wantErr), "expected underlying error to be the processor error") - return nil // the error should be regarded as handled + is.True(cerrors.Is(nackMetadata.Reason, wantErr)) // expected underlying error to be the processor error + return nil // the error should be regarded as handled }) go func() { // publisher @@ -152,15 +155,16 @@ func TestProcessorNode_ErrorWithNackHandler(t *testing.T) { }() err := n.Run(ctx) - assert.Ok(t, err) - assert.Equal(t, MessageStatusNacked, msg.Status()) + is.NoErr(err) + is.Equal(MessageStatusNacked, msg.Status()) // after the node stops the out channel should be closed _, ok := <-out - assert.Equal(t, false, ok) + is.Equal(false, ok) } func TestProcessorNode_Skip(t *testing.T) { + is := is.New(t) ctx := context.Background() ctrl := gomock.NewController(t) @@ -203,10 +207,10 @@ func TestProcessorNode_Skip(t *testing.T) { // run the pipeline and assert that there are no underlying pipeline errors err := n.Run(ctx) - assert.Equal(t, err, nil) - assert.Equal(t, counter, 1) + is.Equal(err, nil) + is.Equal(counter, 1) // after the node stops the out channel should be closed _, ok := <-out - assert.Equal(t, false, ok) + is.Equal(false, ok) } diff --git a/pkg/record/schema/acceptance_testing.go b/pkg/record/schema/acceptance_testing.go index 3591dabee..25877a749 100644 --- a/pkg/record/schema/acceptance_testing.go +++ b/pkg/record/schema/acceptance_testing.go @@ -19,7 +19,7 @@ import ( "strings" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" + "github.com/matryer/is" ) // AcceptanceTest is the acceptance test that all implementations of Schema @@ -36,14 +36,16 @@ func AcceptanceTest(t *testing.T, schema Schema) { // Tests that converting Schema to MutableSchema preserves the descriptors. func testMutableSchemaSameAsSchema(t *testing.T, s Schema) { + is := is.New(t) + t.Run(testName(), func(t *testing.T) { ms := s.ToMutable() - assert.Equal(t, s.Type(), ms.Type()) - assert.Equal(t, s.Version(), ms.Version()) + is.Equal(s.Type(), ms.Type()) + is.Equal(s.Version(), ms.Version()) d1 := s.Descriptors() d2 := ms.Descriptors() - assert.Equal(t, len(d1), len(d2)) + is.Equal(len(d1), len(d2)) for i := 0; i < len(d1); i++ { assertDescriptorsEqual(t, d1[i], d2[i]) } @@ -51,56 +53,60 @@ func testMutableSchemaSameAsSchema(t *testing.T, s Schema) { } func assertDescriptorsEqual(tb testing.TB, d1 Descriptor, d2 Descriptor) { - assert.Equal(tb, d1.Parameters(), d2.Parameters()) + is := is.New(tb) + + is.Equal(d1.Parameters(), d2.Parameters()) switch v1 := d1.(type) { case StructDescriptor: v2, ok := d2.(StructDescriptor) - assert.True(tb, ok, "expected %T, got %T", d1, d2) + is.True(ok) // expected d1 and d2 to be of the same Type StructDescriptor - assert.Equal(tb, v1.Name(), v2.Name()) + is.Equal(v1.Name(), v2.Name()) f1 := v1.Fields() f2 := v2.Fields() - assert.Equal(tb, len(f1), len(f2)) + is.Equal(len(f1), len(f2)) for i := 0; i < len(f1); i++ { assertFieldsEqual(tb, f1[i], f2[i]) } case EnumDescriptor: v2, ok := d2.(EnumDescriptor) - assert.True(tb, ok, "expected %T, got %T", d1, d2) + is.True(ok) // expected d1 and d2 to be of the same Type EnumDescriptor - assert.Equal(tb, v1.Name(), v2.Name()) + is.Equal(v1.Name(), v2.Name()) vd1 := v1.ValueDescriptors() vd2 := v2.ValueDescriptors() - assert.Equal(tb, len(vd1), len(vd2)) + is.Equal(len(vd1), len(vd2)) for i := 0; i < len(vd1); i++ { assertDescriptorsEqual(tb, vd1[i], vd2[i]) } case EnumValueDescriptor: v2, ok := d2.(EnumValueDescriptor) - assert.True(tb, ok, "expected %T, got %T", d1, d2) + is.True(ok) // expected d1 and d2 to be of the same Type EnumValueDescriptor - assert.Equal(tb, v1.Name(), v2.Name()) - assert.Equal(tb, v1.Value(), v2.Value()) + is.Equal(v1.Name(), v2.Name()) + is.Equal(v1.Value(), v2.Value()) case MapDescriptor: v2, ok := d2.(MapDescriptor) - assert.True(tb, ok, "expected %T, got %T", d1, d2) + is.True(ok) // expected d1 and d2 to be of the same Type MapDescriptor assertDescriptorsEqual(tb, v1.KeyDescriptor(), v2.KeyDescriptor()) assertDescriptorsEqual(tb, v1.ValueDescriptor(), v2.ValueDescriptor()) case ArrayDescriptor: v2, ok := d2.(ArrayDescriptor) - assert.True(tb, ok, "expected %T, got %T", d1, d2) + is.True(ok) // expected d1 and d2 to be of the same Type ArrayDescriptor assertDescriptorsEqual(tb, v1.ValueDescriptor(), v2.ValueDescriptor()) } } func assertFieldsEqual(tb testing.TB, f1 Field, f2 Field) { - assert.Equal(tb, f1.Name(), f2.Name()) - assert.Equal(tb, f1.Index(), f2.Index()) + is := is.New(tb) + + is.Equal(f1.Name(), f2.Name()) + is.Equal(f1.Index(), f2.Index()) assertDescriptorsEqual(tb, f1.Descriptor(), f2.Descriptor()) } diff --git a/pkg/record/schema/proto/mutable_test.go b/pkg/record/schema/proto/mutable_test.go index cb5722b18..8564de9eb 100644 --- a/pkg/record/schema/proto/mutable_test.go +++ b/pkg/record/schema/proto/mutable_test.go @@ -19,24 +19,30 @@ import ( "math" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/record/schema" + "github.com/matryer/is" "google.golang.org/protobuf/types/descriptorpb" ) func fileDescriptorSetToMutalbeSchema(t *testing.T, fds *descriptorpb.FileDescriptorSet) *MutableSchema { + is := is.New(t) + s, err := NewSchema(fds, "", 1) - assert.Ok(t, err) + is.NoErr(err) return s.ToMutable().(*MutableSchema) } func TestMutableSchema_Type(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, standaloneDescriptorSetPath)) - assert.Equal(t, SchemaType, ms.Type()) + is.Equal(SchemaType, ms.Type()) } func TestMutableSchema_SetVersion(t *testing.T) { + is := is.New(t) + testCases := []struct { version int wantErr error @@ -52,19 +58,21 @@ func TestMutableSchema_SetVersion(t *testing.T) { for i, tc := range testCases { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, standaloneDescriptorSetPath)) - assert.Equal(t, 1, ms.Version()) + is.Equal(1, ms.Version()) ms.SetVersion(tc.version) - assert.Equal(t, tc.version, ms.Version()) + is.Equal(tc.version, ms.Version()) newSchema, err := ms.Build() assertError(t, tc.wantErr, err) - assert.Equal(t, tc.version, newSchema.Version()) + is.Equal(tc.version, newSchema.Version()) }) } } func TestMutableSchema_SetDescriptors_Panics(t *testing.T) { + is := is.New(t) + testCases := []struct { descriptors []schema.MutableDescriptor wantPanic error @@ -106,23 +114,27 @@ func TestMutableSchema_SetDescriptors_Panics(t *testing.T) { ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, standaloneDescriptorSetPath)) ms.SetDescriptors(tc.descriptors) - assert.True(t, false, "expected panic") + is.Fail() // expected panic }) } } func TestMutableSchema_SetDescriptors_Empty(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, standaloneDescriptorSetPath)) ms.SetDescriptors(nil) - assert.Equal(t, 0, len(ms.Descriptors())) + is.Equal(0, len(ms.Descriptors())) newSchema, err := ms.Build() - assert.Ok(t, err) - assert.Equal(t, 0, len(newSchema.Descriptors())) + is.NoErr(err) + is.Equal(0, len(newSchema.Descriptors())) } func TestMutableSchema_SetDescriptors_Success(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) // only retain Foo, AllTypes and MyEnum @@ -134,59 +146,65 @@ func TestMutableSchema_SetDescriptors_Success(t *testing.T) { ms.SetDescriptors([]schema.MutableDescriptor{fooDesc, allTypesDesc, myEnumDesc}) got := ms.Descriptors() - assert.Equal(t, 3, len(got)) - assert.Equal(t, fooDesc, got[0]) - assert.Equal(t, allTypesDesc, got[1]) - assert.Equal(t, myEnumDesc, got[2]) + is.Equal(3, len(got)) + is.Equal(fooDesc, got[0]) + is.Equal(allTypesDesc, got[1]) + is.Equal(myEnumDesc, got[2]) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got = newSchema.Descriptors() - assert.Equal(t, 3, len(got)) - assert.Equal(t, fooDesc.Name(), got[0].(StructDescriptor).Name()) - assert.Equal(t, fooDesc.Parameters(), got[0].(StructDescriptor).Parameters()) - assert.Equal(t, len(fooDesc.Fields()), len(got[0].(StructDescriptor).Fields())) - - assert.Equal(t, allTypesDesc.Name(), got[1].(StructDescriptor).Name()) - assert.Equal(t, allTypesDesc.Parameters(), got[1].(StructDescriptor).Parameters()) - assert.Equal(t, len(allTypesDesc.Fields()), len(got[1].(StructDescriptor).Fields())) - - assert.Equal(t, myEnumDesc.Name(), got[2].(EnumDescriptor).Name()) - assert.Equal(t, myEnumDesc.Parameters(), got[2].(EnumDescriptor).Parameters()) - assert.Equal(t, len(myEnumDesc.ValueDescriptors()), len(got[2].(EnumDescriptor).ValueDescriptors())) + is.Equal(3, len(got)) + is.Equal(fooDesc.Name(), got[0].(StructDescriptor).Name()) + is.Equal(fooDesc.Parameters(), got[0].(StructDescriptor).Parameters()) + is.Equal(len(fooDesc.Fields()), len(got[0].(StructDescriptor).Fields())) + + is.Equal(allTypesDesc.Name(), got[1].(StructDescriptor).Name()) + is.Equal(allTypesDesc.Parameters(), got[1].(StructDescriptor).Parameters()) + is.Equal(len(allTypesDesc.Fields()), len(got[1].(StructDescriptor).Fields())) + + is.Equal(myEnumDesc.Name(), got[2].(EnumDescriptor).Name()) + is.Equal(myEnumDesc.Parameters(), got[2].(EnumDescriptor).Parameters()) + is.Equal(len(myEnumDesc.ValueDescriptors()), len(got[2].(EnumDescriptor).ValueDescriptors())) } func TestMutableStructDescriptor_SetName_Success(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) emptyDesc := ms.Descriptors()[2].(*MutableStructDescriptor) emptyDesc.SetName("EmptyNew") - assert.Equal(t, "EmptyNew", emptyDesc.Name()) + is.Equal("EmptyNew", emptyDesc.Name()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[2].(StructDescriptor) - assert.Equal(t, "EmptyNew", got.Name()) + is.Equal("EmptyNew", got.Name()) } // Test that changing the name of a type that is referenced by other fields // will produce an error. This can be improved in the future, we can search for // all references and rename them. func TestMutableStructDescriptor_SetName_CannotResolveType(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) fooDesc := ms.Descriptors()[0].(*MutableStructDescriptor) fooDesc.SetName("FooNew") - assert.Equal(t, "FooNew", fooDesc.Name()) + is.Equal("FooNew", fooDesc.Name()) newSchema, err := ms.Build() assertError(t, cerrors.New(`could not create proto registry: proto: message field "proto.AllTypes.f16" cannot resolve type: "proto.Foo" not found`), err) - assert.Equal(t, nil, newSchema) + is.Equal(nil, newSchema) } func TestMutableStructDescriptor_SetFields_NewFieldSuccess(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) fooDesc := ms.Descriptors()[0].(*MutableStructDescriptor) @@ -204,12 +222,12 @@ func TestMutableStructDescriptor_SetFields_NewFieldSuccess(t *testing.T) { fooDesc.SetFields(mutableFields) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotFields := newSchema.Descriptors()[0].(StructDescriptor).Fields() - assert.Equal(t, 3, len(gotFields)) + is.Equal(3, len(gotFields)) gotField := gotFields[2] - assert.Equal(t, "myField", gotField.Name()) - assert.Equal(t, 3, gotField.Index()) + is.Equal("myField", gotField.Name()) + is.Equal(3, gotField.Index()) } func TestMutableStructDescriptor_SetFields_NewFieldConflict(t *testing.T) { @@ -234,34 +252,40 @@ func TestMutableStructDescriptor_SetFields_NewFieldConflict(t *testing.T) { } func TestMutableField_SetName(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) f1Desc := ms.Descriptors()[0].(*MutableStructDescriptor).Fields()[0].(*MutableField) f1Desc.SetName("renamedField") - assert.Equal(t, "renamedField", f1Desc.Name()) + is.Equal("renamedField", f1Desc.Name()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[0].(StructDescriptor).Fields()[0] - assert.Equal(t, "renamedField", got.Name()) + is.Equal("renamedField", got.Name()) } func TestMutableField_SetIndex(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) f1Desc := ms.Descriptors()[0].(*MutableStructDescriptor).Fields()[0].(*MutableField) f1Desc.SetIndex(1234) - assert.Equal(t, 1234, f1Desc.Index()) + is.Equal(1234, f1Desc.Index()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[0].(StructDescriptor).Fields()[0] - assert.Equal(t, 1234, got.Index()) + is.Equal(1234, got.Index()) } func TestMutableField_SetDescriptor_Primitive(t *testing.T) { + is := is.New(t) + testCases := []schema.PrimitiveDescriptorType{ schema.Boolean, schema.Bytes, @@ -282,17 +306,19 @@ func TestMutableField_SetDescriptor_Primitive(t *testing.T) { f1Desc.SetDescriptor(NewMutablePrimitiveDescriptor(ms, tc)) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[0].(StructDescriptor).Fields()[0].Descriptor() d, ok := got.(PrimitiveDescriptor) - assert.True(t, ok, "expected %T, got %T", d, got) - assert.Equal(t, tc, d.Type()) + is.True(ok) // expected d and got to be of the same Type PrimitiveDescriptor + is.Equal(tc, d.Type()) }) } } func TestMutableField_SetDescriptor_Reference(t *testing.T) { + is := is.New(t) + testCases := []struct { mutableDescriptor func(*MutableSchema) schema.MutableDescriptor assertDescriptor func(*testing.T, schema.Descriptor) @@ -302,8 +328,8 @@ func TestMutableField_SetDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "Foo", d.Name()) + is.True(ok) // expected d and got to be of the same Type StructDescriptor + is.Equal("Foo", d.Name()) }, }, { mutableDescriptor: func(s *MutableSchema) schema.MutableDescriptor { @@ -311,8 +337,8 @@ func TestMutableField_SetDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "MyEnum", d.Name()) + is.True(ok) // expected d and got to be of the same Type MutableDescriptor + is.Equal("MyEnum", d.Name()) }, }, { mutableDescriptor: func(s *MutableSchema) schema.MutableDescriptor { @@ -320,10 +346,10 @@ func TestMutableField_SetDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(ArrayDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) + is.True(ok) // expected d and got to be of the same Type ArrayDescriptor pd, ok := d.ValueDescriptor().(PrimitiveDescriptor) - assert.True(t, ok, "expected %T, got %T", pd, d.ValueDescriptor()) - assert.Equal(t, schema.String, pd.Type()) + is.True(ok) // expected d and got to be of the same Type PrimitiveDescriptor + is.Equal(schema.String, pd.Type()) }, // TODO add test for maps once we support creating one out of thin air }} @@ -337,7 +363,7 @@ func TestMutableField_SetDescriptor_Reference(t *testing.T) { f1Desc.SetDescriptor(d) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[0].(StructDescriptor).Fields()[0] tc.assertDescriptor(t, got.Descriptor()) @@ -346,6 +372,8 @@ func TestMutableField_SetDescriptor_Reference(t *testing.T) { } func TestMutableMapDescriptor_SetKeyDescriptor_Success(t *testing.T) { + is := is.New(t) + testCases := []schema.PrimitiveDescriptorType{ schema.Boolean, schema.String, @@ -365,19 +393,21 @@ func TestMutableMapDescriptor_SetKeyDescriptor_Success(t *testing.T) { keyDesc := NewMutablePrimitiveDescriptor(ms, tc) mapDesc.SetKeyDescriptor(keyDesc) - assert.Equal(t, keyDesc, mapDesc.keyDescriptor) + is.Equal(keyDesc, mapDesc.keyDescriptor) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotMapDesc := newSchema.Descriptors()[1].(StructDescriptor).Fields()[17].Descriptor().(MapDescriptor) gotKeyDesc := gotMapDesc.KeyDescriptor().(PrimitiveDescriptor) - assert.Equal(t, tc, gotKeyDesc.Type()) + is.Equal(tc, gotKeyDesc.Type()) }) } } func TestMutableMapDescriptor_SetKeyDescriptor_InvalidKeyKind(t *testing.T) { + is := is.New(t) + testCases := []struct { descriptorType schema.PrimitiveDescriptorType wantErr error @@ -405,7 +435,7 @@ func TestMutableMapDescriptor_SetKeyDescriptor_InvalidKeyKind(t *testing.T) { keyDesc := NewMutablePrimitiveDescriptor(ms, tc.descriptorType) mapDesc.SetKeyDescriptor(keyDesc) - assert.Equal(t, keyDesc, mapDesc.KeyDescriptor()) + is.Equal(keyDesc, mapDesc.KeyDescriptor()) _, err := ms.Build() assertError(t, tc.wantErr, err) @@ -414,6 +444,8 @@ func TestMutableMapDescriptor_SetKeyDescriptor_InvalidKeyKind(t *testing.T) { } func TestMutableMapDescriptor_SetValueDescriptor_Primitive(t *testing.T) { + is := is.New(t) + testCases := []schema.PrimitiveDescriptorType{ schema.Boolean, schema.Bytes, @@ -436,19 +468,21 @@ func TestMutableMapDescriptor_SetValueDescriptor_Primitive(t *testing.T) { valDesc := NewMutablePrimitiveDescriptor(ms, tc) mapDesc.SetValueDescriptor(valDesc) - assert.Equal(t, valDesc, mapDesc.ValueDescriptor()) + is.Equal(valDesc, mapDesc.ValueDescriptor()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotMapDesc := newSchema.Descriptors()[1].(StructDescriptor).Fields()[17].Descriptor().(MapDescriptor) gotValDesc := gotMapDesc.ValueDescriptor().(PrimitiveDescriptor) - assert.Equal(t, tc, gotValDesc.Type()) + is.Equal(tc, gotValDesc.Type()) }) } } func TestMutableMapDescriptor_SetValueDescriptor_Reference(t *testing.T) { + is := is.New(t) + testCases := []struct { mutableDescriptor func(*MutableSchema) schema.MutableDescriptor assertDescriptor func(*testing.T, schema.Descriptor) @@ -458,8 +492,8 @@ func TestMutableMapDescriptor_SetValueDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "Foo", d.Name()) + is.True(ok) // expected d and got to be of the same Type StructDescriptor + is.Equal("Foo", d.Name()) }, }, { mutableDescriptor: func(s *MutableSchema) schema.MutableDescriptor { @@ -467,8 +501,8 @@ func TestMutableMapDescriptor_SetValueDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "MyEnum", d.Name()) + is.True(ok) // expected d and got to be of the same Type EnumDescriptor + is.Equal("MyEnum", d.Name()) }, }} @@ -482,10 +516,10 @@ func TestMutableMapDescriptor_SetValueDescriptor_Reference(t *testing.T) { valDesc := tc.mutableDescriptor(ms) mapDesc.SetValueDescriptor(valDesc) - assert.Equal(t, valDesc, mapDesc.ValueDescriptor()) + is.Equal(valDesc, mapDesc.ValueDescriptor()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotDesc := newSchema.Descriptors()[1].(StructDescriptor).Fields()[17].Descriptor().(MapDescriptor).valueDescriptor tc.assertDescriptor(t, gotDesc) }) @@ -493,6 +527,8 @@ func TestMutableMapDescriptor_SetValueDescriptor_Reference(t *testing.T) { } func TestMutableArrayDescriptor_SetValueDescriptor_Primitive(t *testing.T) { + is := is.New(t) + testCases := []schema.PrimitiveDescriptorType{ schema.Boolean, schema.Bytes, @@ -515,19 +551,21 @@ func TestMutableArrayDescriptor_SetValueDescriptor_Primitive(t *testing.T) { valDesc := NewMutablePrimitiveDescriptor(ms, tc) arrayDesc.SetValueDescriptor(valDesc) - assert.Equal(t, valDesc, arrayDesc.ValueDescriptor()) + is.Equal(valDesc, arrayDesc.ValueDescriptor()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotArrayDesc := newSchema.Descriptors()[1].(StructDescriptor).Fields()[16].Descriptor().(ArrayDescriptor) gotValDesc := gotArrayDesc.ValueDescriptor().(PrimitiveDescriptor) - assert.Equal(t, tc, gotValDesc.Type()) + is.Equal(tc, gotValDesc.Type()) }) } } func TestMutableArrayDescriptor_SetValueDescriptor_Reference(t *testing.T) { + is := is.New(t) + testCases := []struct { mutableDescriptor func(*MutableSchema) schema.MutableDescriptor assertDescriptor func(*testing.T, schema.Descriptor) @@ -537,8 +575,8 @@ func TestMutableArrayDescriptor_SetValueDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "Foo", d.Name()) + is.True(ok) + is.Equal("Foo", d.Name()) }, }, { mutableDescriptor: func(s *MutableSchema) schema.MutableDescriptor { @@ -546,8 +584,8 @@ func TestMutableArrayDescriptor_SetValueDescriptor_Reference(t *testing.T) { }, assertDescriptor: func(t *testing.T, descriptor schema.Descriptor) { d, ok := descriptor.(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", d, descriptor) - assert.Equal(t, "MyEnum", d.Name()) + is.True(ok) + is.Equal("MyEnum", d.Name()) }, }} @@ -561,10 +599,10 @@ func TestMutableArrayDescriptor_SetValueDescriptor_Reference(t *testing.T) { valDesc := tc.mutableDescriptor(ms) arrayDesc.SetValueDescriptor(valDesc) - assert.Equal(t, valDesc, arrayDesc.ValueDescriptor()) + is.Equal(valDesc, arrayDesc.ValueDescriptor()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotDesc := newSchema.Descriptors()[1].(StructDescriptor).Fields()[16].Descriptor().(ArrayDescriptor).valueDescriptor tc.assertDescriptor(t, gotDesc) }) @@ -572,20 +610,24 @@ func TestMutableArrayDescriptor_SetValueDescriptor_Reference(t *testing.T) { } func TestMutableEnumDescriptor_SetName_Success(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) enumDesc := ms.Descriptors()[5].(*MutableEnumDescriptor) enumDesc.SetName("UnusedEnumNew") - assert.Equal(t, "UnusedEnumNew", enumDesc.Name()) + is.Equal("UnusedEnumNew", enumDesc.Name()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[5].(EnumDescriptor) - assert.Equal(t, "UnusedEnumNew", got.Name()) + is.Equal("UnusedEnumNew", got.Name()) } func TestMutableEnumDescriptor_SetValueDescriptors_NewValueSuccess(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) enumDesc := ms.Descriptors()[5].(*MutableEnumDescriptor) @@ -603,12 +645,12 @@ func TestMutableEnumDescriptor_SetValueDescriptors_NewValueSuccess(t *testing.T) enumDesc.SetValueDescriptors(mutableValues) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotValues := newSchema.Descriptors()[5].(EnumDescriptor).ValueDescriptors() - assert.Equal(t, 3, len(gotValues)) + is.Equal(3, len(gotValues)) gotValue := gotValues[2] - assert.Equal(t, "myValue", gotValue.Name()) - assert.Equal(t, "3", gotValue.Value()) + is.Equal("myValue", gotValue.Name()) + is.Equal("3", gotValue.Value()) } func TestMutableEnumDescriptor_SetValues_NewValueConflict(t *testing.T) { @@ -633,46 +675,54 @@ func TestMutableEnumDescriptor_SetValues_NewValueConflict(t *testing.T) { } func TestMutableEnumValueDescriptor_SetName_Success(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) enumDesc := ms.Descriptors()[5].(*MutableEnumDescriptor).ValueDescriptors()[0].(*MutableEnumValueDescriptor) enumDesc.SetName("V0New") - assert.Equal(t, "V0New", enumDesc.Name()) + is.Equal("V0New", enumDesc.Name()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[5].(EnumDescriptor).ValueDescriptors()[0] - assert.Equal(t, "V0New", got.Name()) + is.Equal("V0New", got.Name()) } func TestMutableEnumValueDescriptor_SetValue_Success(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) enumDesc := ms.Descriptors()[5].(*MutableEnumDescriptor).ValueDescriptors()[1].(*MutableEnumValueDescriptor) enumDesc.SetValue("1") - assert.Equal(t, "1", enumDesc.Value()) + is.Equal("1", enumDesc.Value()) newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) got := newSchema.Descriptors()[5].(EnumDescriptor).ValueDescriptors()[1] - assert.Equal(t, "1", got.Value()) + is.Equal("1", got.Value()) } func TestMutableEnumValueDescriptor_SetValue_MissingZeroNumber(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) enumDesc := ms.Descriptors()[5].(*MutableEnumDescriptor).ValueDescriptors()[0].(*MutableEnumValueDescriptor) enumDesc.SetValue("1") - assert.Equal(t, "1", enumDesc.Value()) + is.Equal("1", enumDesc.Value()) _, err := ms.Build() assertError(t, cerrors.New(`could not create proto registry: proto: enum "proto.V1" using proto3 semantics must have zero number for the first value`), err) } func TestMutablePrimitiveDescriptor_Type(t *testing.T) { + is := is.New(t) + ms := fileDescriptorSetToMutalbeSchema(t, getFileDescriptorSet(t, test1DescriptorSetPath)) allTypesDesc := ms.Descriptors()[1].(*MutableStructDescriptor) @@ -697,13 +747,15 @@ func TestMutablePrimitiveDescriptor_Type(t *testing.T) { for index, wantType := range wantTypes { t.Run(fmt.Sprintf("f%d", index+1), func(t *testing.T) { pd, ok := allTypesDesc.Fields()[index].Descriptor().(*MutablePrimitiveDescriptor) - assert.True(t, ok, fmt.Sprintf("expected %T, got %T", pd, allTypesDesc.Fields()[index].Descriptor())) - assert.Equal(t, wantType, pd.Type()) + is.True(ok) // expected d and got to be of the same Type MutablePrimitiveDescriptor + is.Equal(wantType, pd.Type()) }) } } func TestMutablePrimitiveDescriptor_SetType(t *testing.T) { + is := is.New(t) + testCases := []schema.PrimitiveDescriptorType{ schema.Boolean, schema.Bytes, @@ -729,18 +781,18 @@ func TestMutablePrimitiveDescriptor_SetType(t *testing.T) { d := f.Descriptor().(*MutablePrimitiveDescriptor) d.SetType(tc) - assert.Equal(t, tc, d.Type()) + is.Equal(tc, d.Type()) } newSchema, err := ms.Build() - assert.Ok(t, err) + is.NoErr(err) gotAllTypesDesc := newSchema.Descriptors()[1].(StructDescriptor) for i, f := range gotAllTypesDesc.Fields() { if i == 15 { // only first 15 fields are primitive types break } - assert.Equal(t, tc, f.Descriptor().(PrimitiveDescriptor).Type()) + is.Equal(tc, f.Descriptor().(PrimitiveDescriptor).Type()) } }) } diff --git a/pkg/record/schema/proto/schema_test.go b/pkg/record/schema/proto/schema_test.go index e83a0cd97..fc356156e 100644 --- a/pkg/record/schema/proto/schema_test.go +++ b/pkg/record/schema/proto/schema_test.go @@ -19,12 +19,13 @@ import ( "io" "math" "os" + "reflect" "strings" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/record/schema" + "github.com/matryer/is" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/descriptorpb" ) @@ -35,15 +36,17 @@ const ( ) func getFileDescriptorSet(t *testing.T, path string) *descriptorpb.FileDescriptorSet { + is := is.New(t) + f, err := os.Open(path) - assert.Ok(t, err) + is.NoErr(err) content, err := io.ReadAll(f) - assert.Ok(t, err) + is.NoErr(err) var fds descriptorpb.FileDescriptorSet err = proto.Unmarshal(content, &fds) - assert.Ok(t, err) + is.NoErr(err) return &fds } @@ -88,6 +91,8 @@ func TestNewSchema(t *testing.T) { // TestSchema runs the generic acceptance test. func TestSchema(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -107,21 +112,25 @@ func TestSchema(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) schema.AcceptanceTest(t, s) }) } } func TestSchema_Type(t *testing.T) { + is := is.New(t) + fds := getFileDescriptorSet(t, standaloneDescriptorSetPath) s, err := NewSchema(fds, "", 1) - assert.Ok(t, err) - assert.Equal(t, SchemaType, s.Type()) + is.NoErr(err) + is.Equal(SchemaType, s.Type()) } func TestSchema_Version(t *testing.T) { + is := is.New(t) + testCases := []struct { version int wantErr error @@ -140,12 +149,14 @@ func TestSchema_Version(t *testing.T) { s, err := NewSchema(fds, "", tc.version) assertError(t, tc.wantErr, err) - assert.Equal(t, tc.version, s.Version()) + is.Equal(tc.version, s.Version()) }) } } func TestSchema_Descriptors(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -154,41 +165,41 @@ func TestSchema_Descriptors(t *testing.T) { path: standaloneDescriptorSetPath, mainDescriptor: "", assertDescriptors: func(t *testing.T, descriptors []schema.Descriptor) { - assert.Equal(t, 1, len(descriptors)) + is.Equal(1, len(descriptors)) sd, ok := descriptors[0].(StructDescriptor) - assert.Equal(t, true, ok) - assert.Equal(t, "Foo", sd.Name()) + is.Equal(true, ok) + is.Equal("Foo", sd.Name()) }, }, { path: test1DescriptorSetPath, mainDescriptor: "", assertDescriptors: func(t *testing.T, descriptors []schema.Descriptor) { - assert.Equal(t, 6, len(descriptors)) + is.Equal(6, len(descriptors)) d1, ok := descriptors[0].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptors[0]) - assert.Equal(t, "Foo", d1.Name()) + is.True(ok) // expected element 0 in descriptors to be of Type StructDescriptor + is.Equal("Foo", d1.Name()) d2, ok := descriptors[1].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptors[1]) - assert.Equal(t, "AllTypes", d2.Name()) + is.True(ok) // expected element 2 in descriptors to be of Type StructDescriptor + is.Equal("AllTypes", d2.Name()) d3, ok := descriptors[2].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptors[2]) - assert.Equal(t, "Empty", d3.Name()) + is.True(ok) // expected element 2 in descriptors to be of Type StructDescriptor + is.Equal("Empty", d3.Name()) d4, ok := descriptors[3].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptors[3]) - assert.Equal(t, "Nested", d4.Name()) + is.True(ok) // expected element 3 in descriptors to be of Type StructDescriptor + is.Equal("Nested", d4.Name()) d5, ok := descriptors[4].(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", EnumDescriptor{}, descriptors[4]) - assert.Equal(t, "MyEnum", d5.Name()) + is.True(ok) // expected element 4 in descriptors to be of Type EnumDescriptor + is.Equal("MyEnum", d5.Name()) d6, ok := descriptors[5].(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", EnumDescriptor{}, descriptors[5]) - assert.Equal(t, "UnusedEnum", d6.Name()) + is.True(ok) // expected element 5 in descriptors to be of Type EnumDescriptor + is.Equal("UnusedEnum", d6.Name()) }, }} @@ -196,7 +207,7 @@ func TestSchema_Descriptors(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) tc.assertDescriptors(t, s.Descriptors()) }) @@ -204,6 +215,8 @@ func TestSchema_Descriptors(t *testing.T) { } func TestStructDescriptor_Fields(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -214,41 +227,41 @@ func TestStructDescriptor_Fields(t *testing.T) { mainDescriptor: "", getDescriptor: func(t *testing.T, s schema.Schema) StructDescriptor { d, ok := s.Descriptors()[1].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, s.Descriptors()[1]) - assert.Equal(t, "AllTypes", d.Name()) + is.True(ok) // expected to be of Type StructDescriptor + is.Equal("AllTypes", d.Name()) return d }, assertDescriptor: func(t *testing.T, descriptor StructDescriptor) { fields := descriptor.Fields() - assert.Equal(t, 19, len(fields)) + is.Equal(19, len(fields)) for i, f := range fields { - assert.Equal(t, fmt.Sprintf("f%d", i+1), f.Name()) + is.Equal(fmt.Sprintf("f%d", i+1), f.Name()) if i < 19 { - assert.Equal(t, i+1, f.Index()) + is.Equal(i+1, f.Index()) } else { - assert.Equal(t, (i+1)*10, f.Index()) + is.Equal((i+1)*10, f.Index()) } switch i { case 15: - _, ok := f.Descriptor().(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, f.Descriptor()) + // expected to be of Type StructDescriptor + is.Equal(reflect.TypeOf(StructDescriptor{}), reflect.TypeOf(f.Descriptor())) case 16: - _, ok := f.Descriptor().(ArrayDescriptor) - assert.True(t, ok, "expected %T, got %T", ArrayDescriptor{}, f.Descriptor()) + // expected to be of Type ArrayDescriptor + is.Equal(reflect.TypeOf(ArrayDescriptor{}), reflect.TypeOf(f.Descriptor())) case 17: - _, ok := f.Descriptor().(MapDescriptor) - assert.True(t, ok, "expected %T, got %T", MapDescriptor{}, f.Descriptor()) + // expected to be of Type MapDescriptor + is.Equal(reflect.TypeOf(MapDescriptor{}), reflect.TypeOf(f.Descriptor())) case 18: - _, ok := f.Descriptor().(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", EnumDescriptor{}, f.Descriptor()) + // expected to be of Type EnumDescriptor + is.Equal(reflect.TypeOf(EnumDescriptor{}), reflect.TypeOf(f.Descriptor())) default: // first 15 fields should be primitive types - _, ok := f.Descriptor().(PrimitiveDescriptor) - assert.True(t, ok, "expected %T, got %T", PrimitiveDescriptor{}, f.Descriptor()) + // expected to be of Type PrimitiveDescriptor + is.Equal(reflect.TypeOf(PrimitiveDescriptor{}), reflect.TypeOf(f.Descriptor())) } } }, @@ -257,26 +270,26 @@ func TestStructDescriptor_Fields(t *testing.T) { mainDescriptor: "", getDescriptor: func(t *testing.T, s schema.Schema) StructDescriptor { d, ok := s.Descriptors()[0].(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, s.Descriptors()[0]) - assert.Equal(t, "Foo", d.Name()) + is.True(ok) // expected to be of Type StructDescriptor + is.Equal("Foo", d.Name()) return d }, assertDescriptor: func(t *testing.T, descriptor StructDescriptor) { fields := descriptor.Fields() - assert.Equal(t, 2, len(fields)) + is.Equal(2, len(fields)) - assert.Equal(t, "key", fields[0].Name()) - assert.Equal(t, 1, fields[0].Index()) + is.Equal("key", fields[0].Name()) + is.Equal(1, fields[0].Index()) d1, ok := fields[0].Descriptor().(PrimitiveDescriptor) - assert.Equal(t, true, ok) - assert.Equal(t, schema.String, d1.Type()) + is.Equal(true, ok) + is.Equal(schema.String, d1.Type()) - assert.Equal(t, "value", fields[1].Name()) - assert.Equal(t, 2, fields[1].Index()) + is.Equal("value", fields[1].Name()) + is.Equal(2, fields[1].Index()) d2, ok := fields[1].Descriptor().(PrimitiveDescriptor) - assert.Equal(t, true, ok) - assert.Equal(t, schema.String, d2.Type()) + is.Equal(true, ok) + is.Equal(schema.String, d2.Type()) }, }} @@ -284,7 +297,7 @@ func TestStructDescriptor_Fields(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) sd := tc.getDescriptor(t, s) tc.assertDescriptor(t, sd) @@ -293,6 +306,8 @@ func TestStructDescriptor_Fields(t *testing.T) { } func TestArrayDescriptor(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -304,13 +319,13 @@ func TestArrayDescriptor(t *testing.T) { getDescriptor: func(t *testing.T, s schema.Schema) ArrayDescriptor { // get descriptor for AllTypes.f17, it is an array d, ok := s.Descriptors()[1].(StructDescriptor).Fields()[16].Descriptor().(ArrayDescriptor) - assert.True(t, ok, "expected %T, got %T", ArrayDescriptor{}, s.Descriptors()[1].(StructDescriptor).Fields()[16].Descriptor()) + is.True(ok) // expected to be of Type ArrayDescriptor return d }, assertDescriptor: func(t *testing.T, descriptor ArrayDescriptor) { d, ok := descriptor.ValueDescriptor().(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptor.ValueDescriptor()) - assert.Equal(t, "Foo", d.Name()) + is.True(ok) // expected to be of Type StructDescriptor + is.Equal("Foo", d.Name()) }, }} @@ -318,7 +333,7 @@ func TestArrayDescriptor(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) sd := tc.getDescriptor(t, s) tc.assertDescriptor(t, sd) @@ -327,6 +342,8 @@ func TestArrayDescriptor(t *testing.T) { } func TestMapDescriptor(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -338,17 +355,17 @@ func TestMapDescriptor(t *testing.T) { getDescriptor: func(t *testing.T, s schema.Schema) MapDescriptor { // get descriptor for AllTypes.f18, it is a map d, ok := s.Descriptors()[1].(StructDescriptor).Fields()[17].Descriptor().(MapDescriptor) - assert.True(t, ok, "expected %T, got %T", MapDescriptor{}, s.Descriptors()[1].(StructDescriptor).Fields()[17].Descriptor()) + is.True(ok) // expected to be of Type MapDescriptor return d }, assertDescriptor: func(t *testing.T, descriptor MapDescriptor) { d1, ok := descriptor.KeyDescriptor().(PrimitiveDescriptor) - assert.True(t, ok, "expected %T, got %T", PrimitiveDescriptor{}, descriptor.KeyDescriptor()) - assert.Equal(t, schema.String, d1.Type()) + is.True(ok) // expected to be of Type PrimitiveDescriptor + is.Equal(schema.String, d1.Type()) d2, ok := descriptor.ValueDescriptor().(StructDescriptor) - assert.True(t, ok, "expected %T, got %T", StructDescriptor{}, descriptor.ValueDescriptor()) - assert.Equal(t, "Foo", d2.Name()) + is.True(ok) // expected to be of Type StructDescriptor + is.Equal("Foo", d2.Name()) }, }} @@ -356,7 +373,7 @@ func TestMapDescriptor(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) sd := tc.getDescriptor(t, s) tc.assertDescriptor(t, sd) @@ -365,6 +382,8 @@ func TestMapDescriptor(t *testing.T) { } func TestEnumDescriptor(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -376,24 +395,24 @@ func TestEnumDescriptor(t *testing.T) { getDescriptor: func(t *testing.T, s schema.Schema) EnumDescriptor { // get descriptor for AllTypes.f19, it is an enum d, ok := s.Descriptors()[1].(StructDescriptor).Fields()[18].Descriptor().(EnumDescriptor) - assert.True(t, ok, "expected %T, got %T", EnumDescriptor{}, s.Descriptors()[1].(StructDescriptor).Fields()[18].Descriptor()) + is.True(ok) // expected to be of Type EnumDescriptor return d }, assertDescriptor: func(t *testing.T, descriptor EnumDescriptor) { - assert.Equal(t, "MyEnum", descriptor.Name()) - assert.Equal(t, 3, len(descriptor.ValueDescriptors())) + is.Equal("MyEnum", descriptor.Name()) + is.Equal(3, len(descriptor.ValueDescriptors())) vd1 := descriptor.ValueDescriptors()[0] - assert.Equal(t, "Val0", vd1.Name()) - assert.Equal(t, "0", vd1.Value()) + is.Equal("Val0", vd1.Name()) + is.Equal("0", vd1.Value()) vd2 := descriptor.ValueDescriptors()[1] - assert.Equal(t, "Val1", vd2.Name()) - assert.Equal(t, "1", vd2.Value()) + is.Equal("Val1", vd2.Name()) + is.Equal("1", vd2.Value()) vd3 := descriptor.ValueDescriptors()[2] - assert.Equal(t, "Val5", vd3.Name()) - assert.Equal(t, "5", vd3.Value()) + is.Equal("Val5", vd3.Name()) + is.Equal("5", vd3.Value()) }, }} @@ -401,7 +420,7 @@ func TestEnumDescriptor(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) sd := tc.getDescriptor(t, s) tc.assertDescriptor(t, sd) @@ -410,6 +429,8 @@ func TestEnumDescriptor(t *testing.T) { } func TestReusedDescriptors(t *testing.T) { + is := is.New(t) + testCases := []struct { path string mainDescriptor string @@ -443,25 +464,26 @@ func TestReusedDescriptors(t *testing.T) { t.Run(fmt.Sprintf("test case %d", i), func(t *testing.T) { fds := getFileDescriptorSet(t, tc.path) s, err := NewSchema(fds, tc.mainDescriptor, 1) - assert.Ok(t, err) + is.NoErr(err) d1 := tc.getDescriptor1(t, s) d2 := tc.getDescriptor2(t, s) - assert.Equal(t, d1, d2) + is.Equal(d1, d2) }) } } // assertError fails if the errors do not match. func assertError(tb testing.TB, want error, got error) { + is := is.New(tb) //nolint:gocritic // no single value to have a switch on if want == nil { - assert.Ok(tb, got) + is.NoErr(got) } else if got == nil { - assert.Equal(tb, want.Error(), got) + is.Equal(want.Error(), got) } else { // sanitize error string, protobuf randomly adds a non-breaking space errStr := strings.ReplaceAll(got.Error(), "\u00a0", " ") - assert.Equal(tb, want.Error(), errStr) + is.Equal(want.Error(), errStr) } } diff --git a/pkg/web/api/connector_v1_test.go b/pkg/web/api/connector_v1_test.go index eb323b33f..01d3749cf 100644 --- a/pkg/web/api/connector_v1_test.go +++ b/pkg/web/api/connector_v1_test.go @@ -21,7 +21,6 @@ import ( "time" "github.com/conduitio/conduit/pkg/connector" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cchan" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/foundation/log" @@ -31,11 +30,14 @@ import ( "github.com/conduitio/conduit/pkg/web/api/toproto" apiv1 "github.com/conduitio/conduit/proto/api/v1" "github.com/google/uuid" + "github.com/matryer/is" "go.uber.org/mock/gomock" "google.golang.org/protobuf/types/known/timestamppb" ) func TestConnectorAPIv1_ListConnectors(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -97,7 +99,7 @@ func TestConnectorAPIv1_ListConnectors(t *testing.T) { ctx, &apiv1.ListConnectorsRequest{}, ) - assert.Ok(t, err) + is.NoErr(err) // copy expected times for i, conn := range got.Connectors { @@ -107,10 +109,12 @@ func TestConnectorAPIv1_ListConnectors(t *testing.T) { sortConnectors(want.Connectors) sortConnectors(got.Connectors) - assert.Equal(t, want, got) + is.Equal(want, got) } func TestConnectorAPIv1_ListConnectorsByPipeline(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -150,7 +154,7 @@ func TestConnectorAPIv1_ListConnectorsByPipeline(t *testing.T) { ctx, &apiv1.ListConnectorsRequest{PipelineId: source.PipelineID}, ) - assert.Ok(t, err) + is.NoErr(err) // copy expected time for i, conn := range got.Connectors { @@ -158,10 +162,12 @@ func TestConnectorAPIv1_ListConnectorsByPipeline(t *testing.T) { conn.UpdatedAt = want.Connectors[i].UpdatedAt } - assert.Equal(t, want, got) + is.Equal(want, got) } func TestConnectorAPIv1_CreateConnector(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -199,16 +205,18 @@ func TestConnectorAPIv1_CreateConnector(t *testing.T) { }, ) - assert.Ok(t, err) + is.NoErr(err) // copy expected time got.Connector.CreatedAt = want.Connector.CreatedAt got.Connector.UpdatedAt = want.Connector.UpdatedAt - assert.Equal(t, want, got) + is.Equal(want, got) } func TestConnectorAPIv1_InspectConnector_SendRecord(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -218,7 +226,7 @@ func TestConnectorAPIv1_InspectConnector_SendRecord(t *testing.T) { id := uuid.NewString() rec := generateTestRecord() recProto, err := toproto.Record(rec) - assert.Ok(t, err) + is.NoErr(err) ins := inspector.New(log.Nop(), 10) session := ins.NewSession(ctx, "test-id") @@ -244,6 +252,8 @@ func TestConnectorAPIv1_InspectConnector_SendRecord(t *testing.T) { } func TestConnectorAPIv1_InspectConnector_SendErr(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -275,12 +285,14 @@ func TestConnectorAPIv1_InspectConnector_SendErr(t *testing.T) { ins.Send(ctx, generateTestRecord()) err, b, err2 := cchan.ChanOut[error](errC).RecvTimeout(context.Background(), 100*time.Millisecond) - assert.Ok(t, err2) - assert.True(t, b, "expected to receive an error") - assert.True(t, cerrors.Is(err, errSend), "expected 'I'm sorry, but no.' error") + is.NoErr(err2) + is.True(b) // expected to receive an error + is.True(cerrors.Is(err, errSend)) // expected 'I'm sorry, but no.' error" } func TestConnectorAPIv1_InspectConnector_Err(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -301,9 +313,8 @@ func TestConnectorAPIv1_InspectConnector_Err(t *testing.T) { &apiv1.InspectConnectorRequest{Id: id}, inspectServer, ) - assert.NotNil(t, errAPI) - assert.Equal( - t, + is.True(errAPI != nil) + is.Equal( "rpc error: code = Internal desc = failed to inspect connector: not found, sorry", errAPI.Error(), ) @@ -322,6 +333,8 @@ func generateTestRecord() record.Record { } func TestConnectorAPIv1_GetConnector(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -356,16 +369,18 @@ func TestConnectorAPIv1_GetConnector(t *testing.T) { }, ) - assert.Ok(t, err) + is.NoErr(err) // copy expected time got.Connector.CreatedAt = want.Connector.CreatedAt got.Connector.UpdatedAt = want.Connector.UpdatedAt - assert.Equal(t, want, got) + is.Equal(want, got) } func TestConnectorAPIv1_UpdateConnector(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -407,16 +422,18 @@ func TestConnectorAPIv1_UpdateConnector(t *testing.T) { Config: want.Connector.Config, }, ) - assert.Ok(t, err) + is.NoErr(err) // copy expected time got.Connector.CreatedAt = want.Connector.CreatedAt got.Connector.UpdatedAt = want.Connector.UpdatedAt - assert.Equal(t, want, got) + is.Equal(want, got) } func TestConnectorAPIv1_DeleteConnector(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -435,11 +452,13 @@ func TestConnectorAPIv1_DeleteConnector(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestConnectorAPIv1_ValidateConnector(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -467,11 +486,13 @@ func TestConnectorAPIv1_ValidateConnector(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestConnectorAPIv1_ValidateConnectorError(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) csMock := apimock.NewConnectorOrchestrator(ctrl) @@ -498,7 +519,7 @@ func TestConnectorAPIv1_ValidateConnectorError(t *testing.T) { }, ) - assert.Error(t, err) + is.True(err != nil) } func sortConnectors(c []*apiv1.Connector) { diff --git a/pkg/web/api/plugin_v1_test.go b/pkg/web/api/plugin_v1_test.go index 4d70d82f8..68bc4e892 100644 --- a/pkg/web/api/plugin_v1_test.go +++ b/pkg/web/api/plugin_v1_test.go @@ -19,15 +19,17 @@ import ( "sort" "testing" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/plugin" "github.com/conduitio/conduit/pkg/web/api/mock" "github.com/conduitio/conduit/pkg/web/api/toproto" apiv1 "github.com/conduitio/conduit/proto/api/v1" + "github.com/matryer/is" "go.uber.org/mock/gomock" ) func TestPluginAPIv1_ListPluginByName(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := mock.NewPluginOrchestrator(ctrl) @@ -91,11 +93,11 @@ func TestPluginAPIv1_ListPluginByName(t *testing.T) { &apiv1.ListPluginsRequest{Name: "want-.*"}, ) - assert.Ok(t, err) + is.NoErr(err) sortPlugins(want.Plugins) sortPlugins(got.Plugins) - assert.Equal(t, want, got) + is.Equal(want, got) } func sortPlugins(p []*apiv1.PluginSpecifications) { diff --git a/pkg/web/api/processor_v1_test.go b/pkg/web/api/processor_v1_test.go index adcb029cb..fb0a10692 100644 --- a/pkg/web/api/processor_v1_test.go +++ b/pkg/web/api/processor_v1_test.go @@ -20,7 +20,6 @@ import ( "testing" "time" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cchan" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/foundation/log" @@ -31,11 +30,14 @@ import ( "github.com/conduitio/conduit/pkg/web/api/toproto" apiv1 "github.com/conduitio/conduit/proto/api/v1" "github.com/google/uuid" + "github.com/matryer/is" "go.uber.org/mock/gomock" "google.golang.org/protobuf/types/known/timestamppb" ) func TestProcessorAPIv1_ListProcessors(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -112,13 +114,15 @@ func TestProcessorAPIv1_ListProcessors(t *testing.T) { got, err := api.ListProcessors(ctx, &apiv1.ListProcessorsRequest{}) - assert.Ok(t, err) + is.NoErr(err) sortProcessors(want.Processors) sortProcessors(got.Processors) - assert.Equal(t, want, got) + is.Equal(want, got) } func TestProcessorAPIv1_ListProcessorsByParents(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -235,13 +239,15 @@ func TestProcessorAPIv1_ListProcessorsByParents(t *testing.T) { got, err := api.ListProcessors(ctx, &apiv1.ListProcessorsRequest{ParentIds: []string{sharedParent, prs[2].Parent.ID}}) - assert.Ok(t, err) + is.NoErr(err) sortProcessors(want.Processors) sortProcessors(got.Processors) - assert.Equal(t, want, got) + is.Equal(want, got) } func TestProcessorAPIv1_CreateProcessor(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -290,11 +296,13 @@ func TestProcessorAPIv1_CreateProcessor(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestProcessorAPIv1_GetProcessor(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -340,11 +348,13 @@ func TestProcessorAPIv1_GetProcessor(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestProcessorAPIv1_UpdateProcessor(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -392,11 +402,13 @@ func TestProcessorAPIv1_UpdateProcessor(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestProcessorAPIv1_DeleteProcessor(t *testing.T) { + is := is.New(t) + ctx := context.Background() ctrl := gomock.NewController(t) psMock := apimock.NewProcessorOrchestrator(ctrl) @@ -415,11 +427,13 @@ func TestProcessorAPIv1_DeleteProcessor(t *testing.T) { }, ) - assert.Ok(t, err) - assert.Equal(t, want, got) + is.NoErr(err) + is.Equal(want, got) } func TestProcessorAPIv1_InspectIn_SendRecord(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -429,7 +443,7 @@ func TestProcessorAPIv1_InspectIn_SendRecord(t *testing.T) { id := uuid.NewString() rec := generateTestRecord() recProto, err := toproto.Record(rec) - assert.Ok(t, err) + is.NoErr(err) ins := inspector.New(log.Nop(), 10) session := ins.NewSession(ctx, "test-id") @@ -455,6 +469,8 @@ func TestProcessorAPIv1_InspectIn_SendRecord(t *testing.T) { } func TestProcessorAPIv1_InspectIn_SendErr(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -486,12 +502,14 @@ func TestProcessorAPIv1_InspectIn_SendErr(t *testing.T) { ins.Send(ctx, generateTestRecord()) err, b, err2 := cchan.ChanOut[error](errC).RecvTimeout(context.Background(), 100*time.Millisecond) - assert.Ok(t, err2) - assert.True(t, b, "expected to receive an error") - assert.True(t, cerrors.Is(err, errSend), "expected 'I'm sorry, but no.' error") + is.NoErr(err2) + is.True(b) // expected to receive an error + is.True(cerrors.Is(err, errSend)) // expected 'I'm sorry, but no.' error" } func TestProcessorAPIv1_InspectIn_Err(t *testing.T) { + is := is.New(t) + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ctrl := gomock.NewController(t) @@ -512,9 +530,8 @@ func TestProcessorAPIv1_InspectIn_Err(t *testing.T) { &apiv1.InspectProcessorInRequest{Id: id}, inspectServer, ) - assert.NotNil(t, errAPI) - assert.Equal( - t, + is.True(errAPI != nil) + is.Equal( "rpc error: code = Internal desc = failed to inspect processor: not found, sorry", errAPI.Error(), ) diff --git a/pkg/web/api/status/status_test.go b/pkg/web/api/status/status_test.go index 2b37456e8..6857a3253 100644 --- a/pkg/web/api/status/status_test.go +++ b/pkg/web/api/status/status_test.go @@ -18,16 +18,18 @@ import ( "testing" "github.com/conduitio/conduit/pkg/connector" - "github.com/conduitio/conduit/pkg/foundation/assert" "github.com/conduitio/conduit/pkg/foundation/cerrors" "github.com/conduitio/conduit/pkg/orchestrator" "github.com/conduitio/conduit/pkg/pipeline" "github.com/conduitio/conduit/pkg/processor" + "github.com/matryer/is" "google.golang.org/grpc/codes" grpcstatus "google.golang.org/grpc/status" ) func TestPipelineError(t *testing.T) { + is := is.New(t) + type args struct { err error } @@ -53,12 +55,14 @@ func TestPipelineError(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, PipelineError(tt.args.err)) + is.Equal(tt.want, PipelineError(tt.args.err)) }) } } func TestConnectorError(t *testing.T) { + is := is.New(t) + type args struct { err error } @@ -84,12 +88,14 @@ func TestConnectorError(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, ConnectorError(tt.args.err)) + is.Equal(tt.want, ConnectorError(tt.args.err)) }) } } func TestProcessorError(t *testing.T) { + is := is.New(t) + type args struct { err error } @@ -115,12 +121,14 @@ func TestProcessorError(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, ProcessorError(tt.args.err)) + is.Equal(tt.want, ProcessorError(tt.args.err)) }) } } func TestCodeFromError(t *testing.T) { + is := is.New(t) + type args struct { err error } @@ -202,7 +210,7 @@ func TestCodeFromError(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert.Equal(t, tt.want, codeFromError(tt.args.err)) + is.Equal(tt.want, codeFromError(tt.args.err)) }) } }