diff --git a/.github/workflows/dapr-bot.yml b/.github/workflows/dapr-bot.yml index 05bbb984..3f15ebc4 100644 --- a/.github/workflows/dapr-bot.yml +++ b/.github/workflows/dapr-bot.yml @@ -21,7 +21,7 @@ jobs: - name: Setup Golang uses: actions/setup-go@v4 with: - go-version: ~1.21 + go-version: ~1.20 cache-dependency-path: | ./.github/workflows/dapr-bot/ diff --git a/.github/workflows/dapr-bot/Makefile b/.github/workflows/dapr-bot/Makefile index d5a1e77f..4e82cf0d 100644 --- a/.github/workflows/dapr-bot/Makefile +++ b/.github/workflows/dapr-bot/Makefile @@ -1,4 +1,4 @@ -GO_COMPAT_VERSION=1.21 +GO_COMPAT_VERSION=1.20 .PHONY: cover cover: diff --git a/.github/workflows/dapr-bot/bot_test.go b/.github/workflows/dapr-bot/bot_test.go index e54724bb..41d7ad1f 100644 --- a/.github/workflows/dapr-bot/bot_test.go +++ b/.github/workflows/dapr-bot/bot_test.go @@ -8,9 +8,10 @@ import ( "github.com/google/go-github/v55/github" "github.com/jinzhu/copier" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -var testBot *Bot = &Bot{ +var testBot = &Bot{ ctx: context.Background(), issueClient: &testClient{}, } @@ -50,7 +51,7 @@ func TestHandleEvent(t *testing.T) { } testEventCopy.IssueCommentEvent.Comment.Body = github.String("/assign") res, err := testBot.HandleEvent(ctx, testEventCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, res) }) @@ -67,7 +68,7 @@ func TestHandleEvent(t *testing.T) { } testEventCopy.IssueCommentEvent.Comment.Body = github.String("/assign \r \ntest body") res, err := testBot.HandleEvent(ctx, testEventCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, res) }) @@ -84,7 +85,7 @@ func TestHandleEvent(t *testing.T) { } testEventCopy.IssueCommentEvent.Comment.Body = github.String("/assign") res, err := testBot.HandleEvent(ctx, testEventCopy) - assert.Error(t, err) + require.Error(t, err) assert.NotEmpty(t, res) }) @@ -99,7 +100,7 @@ func TestHandleEvent(t *testing.T) { } testEventCopy.IssueCommentEvent.Comment.Body = github.String("assign") res, err := testBot.HandleEvent(ctx, testEventCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "no command found", res) }) } @@ -111,7 +112,7 @@ func TestCreateIssueComment(t *testing.T) { } testBot.issueClient = &tc err := testBot.CreateIssueComment("test", testEvent) - assert.Error(t, err) + require.Error(t, err) }) t.Run("create issue comment", func(t *testing.T) { @@ -120,7 +121,7 @@ func TestCreateIssueComment(t *testing.T) { } testBot.issueClient = &tc err := testBot.CreateIssueComment("test", testEvent) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("create issue comment with empty body", func(t *testing.T) { @@ -129,7 +130,7 @@ func TestCreateIssueComment(t *testing.T) { } testBot.issueClient = &tc err := testBot.CreateIssueComment("", testEvent) - assert.Error(t, err) + require.Error(t, err) }) } @@ -140,7 +141,7 @@ func TestAssignIssueToCommenter(t *testing.T) { } testBot.issueClient = &tc assignee, err := testBot.AssignIssueToCommenter(testEvent) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, assignee) }) @@ -156,7 +157,7 @@ func TestAssignIssueToCommenter(t *testing.T) { } testEventCopy.IssueCommentEvent.Issue.Assignees = []*github.User{} assignee, err := testBot.AssignIssueToCommenter(testEventCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "testCommentLogin", assignee) }) @@ -170,7 +171,7 @@ func TestAssignIssueToCommenter(t *testing.T) { } testEventCopy.IssueCommentEvent.Issue.State = github.String("closed") assignee, err := testBot.AssignIssueToCommenter(testEventCopy) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, assignee) }) @@ -184,7 +185,7 @@ func TestAssignIssueToCommenter(t *testing.T) { } testEventCopy.IssueCommentEvent.Issue.Assignees = []*github.User{{Login: github.String("testCommentLogin")}} assignee, err := testBot.AssignIssueToCommenter(testEventCopy) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, assignee) }) @@ -200,7 +201,7 @@ func TestAssignIssueToCommenter(t *testing.T) { } testEventCopy.IssueCommentEvent.Issue.Assignees = []*github.User{{Login: github.String("testCommentLogin2")}} assignee, err := testBot.AssignIssueToCommenter(testEventCopy) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, assignee) }) } diff --git a/.github/workflows/dapr-bot/event_test.go b/.github/workflows/dapr-bot/event_test.go index c3b1ff08..ca0d75bf 100644 --- a/.github/workflows/dapr-bot/event_test.go +++ b/.github/workflows/dapr-bot/event_test.go @@ -8,9 +8,10 @@ import ( "github.com/google/go-github/v55/github" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -var testEvent Event = Event{ +var testEvent = Event{ Type: "issue_comment", Path: "test/test", IssueCommentEvent: &github.IssueCommentEvent{ @@ -36,14 +37,14 @@ func TestProcessEvent(t *testing.T) { } t.Run("process event", func(t *testing.T) { event, err := ProcessEvent(testEvent.Type, testEvent.Path, testEventData) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, event) assert.Equal(t, "test/test", event.Path) }) t.Run("process event with empty path", func(t *testing.T) { event, err := ProcessEvent(testEvent.Type, "", testEventData) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, event) }) @@ -53,14 +54,14 @@ func TestProcessEvent(t *testing.T) { t.Run("process issue_comment event", func(t *testing.T) { event, err := ProcessEvent(testEvent.Type, testEvent.Path, testEventData) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, event) assert.Equal(t, "issue_comment", event.Type) }) t.Run("process invalid event", func(t *testing.T) { event, err := ProcessEvent(testEvent.Type, testEvent.Path, randomData.Bytes()) - assert.Error(t, err) + require.Error(t, err) assert.Empty(t, event) }) } @@ -68,7 +69,7 @@ func TestProcessEvent(t *testing.T) { func TestGetIssueAssignees(t *testing.T) { t.Run("get assignees", func(t *testing.T) { assignees := testEvent.GetIssueAssignees() - assert.Equal(t, 1, len(assignees)) + assert.Len(t, assignees, 1) assert.Equal(t, "testAssignee", assignees[0]) }) } diff --git a/.github/workflows/dapr-bot/go.mod b/.github/workflows/dapr-bot/go.mod index 92904a7e..fa067215 100644 --- a/.github/workflows/dapr-bot/go.mod +++ b/.github/workflows/dapr-bot/go.mod @@ -1,6 +1,6 @@ module github.com/dapr/go-sdk/.github/workflows/dapr-bot -go 1.21 +go 1.20 require ( github.com/google/go-github/v55 v55.0.0 diff --git a/.github/workflows/dapr-bot/go.sum b/.github/workflows/dapr-bot/go.sum index 032416ae..ef940ebb 100644 --- a/.github/workflows/dapr-bot/go.sum +++ b/.github/workflows/dapr-bot/go.sum @@ -8,7 +8,6 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-github/v55 v55.0.0 h1:4pp/1tNMB9X/LuAhs5i0KQAE40NmiR/y6prLNb9x9cg= github.com/google/go-github/v55 v55.0.0/go.mod h1:JLahOTA1DnXzhxEymmFF5PP2tSS9JVNj68mSZNDwskA= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= diff --git a/.github/workflows/release-on-tag.yaml b/.github/workflows/release-on-tag.yaml index 0dda4a08..da27fd70 100644 --- a/.github/workflows/release-on-tag.yaml +++ b/.github/workflows/release-on-tag.yaml @@ -15,7 +15,7 @@ jobs: - name: Setup uses: actions/setup-go@v3 with: - go-version: ^1.19 + go-version: ^1.20 - name: Checkout uses: actions/checkout@v3 diff --git a/.github/workflows/test-dapr-bot.yml b/.github/workflows/test-dapr-bot.yml index 328ad944..7907edbb 100644 --- a/.github/workflows/test-dapr-bot.yml +++ b/.github/workflows/test-dapr-bot.yml @@ -20,10 +20,10 @@ jobs: fail-fast: false matrix: gover: - - "1.21" + - "1.20" env: GOVER: ${{ matrix.gover }} - GOLANGCILINT_VER: v1.54.2 + GOLANGCILINT_VER: v1.55.2 steps: - name: Setup diff --git a/.github/workflows/test-on-push.yaml b/.github/workflows/test-on-push.yaml index b2b7da3a..b92a9825 100644 --- a/.github/workflows/test-on-push.yaml +++ b/.github/workflows/test-on-push.yaml @@ -14,12 +14,11 @@ jobs: fail-fast: false matrix: gover: - - "1.19" - "1.20" - "1.21" env: GOVER: ${{ matrix.gover }} - GOLANGCILINT_VER: v1.54.2 + GOLANGCILINT_VER: v1.55.2 steps: - name: Setup diff --git a/.github/workflows/test-tooling.yml b/.github/workflows/test-tooling.yml index 8389de7e..352f63b2 100644 --- a/.github/workflows/test-tooling.yml +++ b/.github/workflows/test-tooling.yml @@ -20,7 +20,7 @@ jobs: fail-fast: false matrix: gover: - - "1.21" + - "1.20" os: - "ubuntu-latest" - "windows-latest" @@ -28,7 +28,7 @@ jobs: runs-on: ${{ matrix.os }} env: GOVER: ${{ matrix.gover }} - GOLANGCILINT_VER: v1.54.2 # Make sure to bump /tools/check-lint-version/main_test.go + GOLANGCILINT_VER: v1.55.2 # Make sure to bump /tools/check-lint-version/main_test.go steps: - name: Setup diff --git a/.golangci.yml b/.golangci.yml index e91a8c34..f526ef50 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -164,12 +164,6 @@ linters-settings: line-length: 120 # tab width in spaces. Default to 1. tab-width: 1 - unused: - # treat code as a program (not a library) and report unused exported identifiers; default is false. - # XXX: if you enable this setting, unused will report a lot of false-positives in text editors: - # if it's called for subdir of a project it can't find funcs usages. All text editor integrations - # with golangci-lint call it on a directory with the changed file. - check-exported: false unparam: # Inspect exported functions, default is false. Set to true if no external program/library imports your code. # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors: @@ -242,7 +236,7 @@ linters-settings: # Allow multiline assignments to be cuddled. Default is true. allow-multiline-assign: true # Allow case blocks to end with a whitespace. - allow-case-traling-whitespace: true + force-case-trailing-whitespace: 0 # Allow declarations (var) to be cuddled. allow-cuddle-declarations: false @@ -310,6 +304,7 @@ linters: - varcheck - deadcode - golint + - inamedparam issues: exclude-rules: - path: .*_test.go diff --git a/Makefile b/Makefile index a50cf67f..cd2363dd 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ RELEASE_VERSION =v1.0.0-rc-3 GDOC_PORT =8888 -GO_COMPAT_VERSION=1.19 +GO_COMPAT_VERSION=1.20 .PHONY: all all: help diff --git a/actor/manager/container_test.go b/actor/manager/container_test.go index c76036a8..a31a4f21 100644 --- a/actor/manager/container_test.go +++ b/actor/manager/container_test.go @@ -72,7 +72,7 @@ func TestContainerInvoke(t *testing.T) { mockCodec.EXPECT().Unmarshal([]byte(param), gomock.Any()).SetArg(1, "param").Return(nil) rsp, err := container.Invoke("Invoke", []byte(param)) - require.Equal(t, 2, len(rsp)) + require.Len(t, rsp, 2) require.Equal(t, actorErr.Success, err) assert.Equal(t, param, rsp[0].Interface().(string)) } diff --git a/client/actor.go b/client/actor.go index 6f6f0f6b..c7099aa4 100644 --- a/client/actor.go +++ b/client/actor.go @@ -74,7 +74,7 @@ func (c *GRPCClient) InvokeActor(ctx context.Context, in *InvokeActorRequest) (o out = &InvokeActorResponse{} if resp != nil { - out.Data = resp.Data + out.Data = resp.GetData() } return out, nil @@ -421,7 +421,7 @@ func (c *GRPCClient) GetActorState(ctx context.Context, in *GetActorStateRequest if err != nil { return nil, fmt.Errorf("error invoking actor get state %s/%s: %w", in.ActorType, in.ActorID, err) } - return &GetActorStateResponse{Data: rsp.Data}, nil + return &GetActorStateResponse{Data: rsp.GetData()}, nil } type ActorStateOperation struct { diff --git a/client/actor_test.go b/client/actor_test.go index 26e54636..a5cf468b 100644 --- a/client/actor_test.go +++ b/client/actor_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -35,7 +37,7 @@ func TestInvokeActor(t *testing.T) { in.Data = nil out, err := testClient.InvokeActor(ctx, in) in.Data = []byte(`{hello}`) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) @@ -43,7 +45,7 @@ func TestInvokeActor(t *testing.T) { in.Method = "" out, err := testClient.InvokeActor(ctx, in) in.Method = "mockMethod" - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) @@ -51,7 +53,7 @@ func TestInvokeActor(t *testing.T) { in.ActorID = "" out, err := testClient.InvokeActor(ctx, in) in.ActorID = "fn" - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) @@ -59,14 +61,14 @@ func TestInvokeActor(t *testing.T) { in.ActorType = "" out, err := testClient.InvokeActor(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) t.Run("invoke actor without empty input", func(t *testing.T) { in = nil out, err := testClient.InvokeActor(ctx, in) - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) } @@ -87,50 +89,50 @@ func TestRegisterActorReminder(t *testing.T) { in.ActorType = "" err := testClient.RegisterActorReminder(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor reminder without id ", func(t *testing.T) { in.ActorID = "" err := testClient.RegisterActorReminder(ctx, in) in.ActorID = "fn" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor reminder without Name ", func(t *testing.T) { in.Name = "" err := testClient.RegisterActorReminder(ctx, in) in.Name = "mockName" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor reminder without period ", func(t *testing.T) { in.Period = "" err := testClient.RegisterActorReminder(ctx, in) in.Period = "2s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor reminder without dutTime ", func(t *testing.T) { in.DueTime = "" err := testClient.RegisterActorReminder(ctx, in) in.DueTime = "2s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor reminder without TTL ", func(t *testing.T) { in.TTL = "" err := testClient.RegisterActorReminder(ctx, in) in.TTL = "20s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor reminder ", func(t *testing.T) { - assert.NoError(t, testClient.RegisterActorReminder(ctx, in)) + require.NoError(t, testClient.RegisterActorReminder(ctx, in)) }) t.Run("invoke register actor reminder with empty param", func(t *testing.T) { - assert.Error(t, testClient.RegisterActorReminder(ctx, nil)) + require.Error(t, testClient.RegisterActorReminder(ctx, nil)) }) } @@ -151,64 +153,64 @@ func TestRegisterActorTimer(t *testing.T) { in.ActorType = "" err := testClient.RegisterActorTimer(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without id ", func(t *testing.T) { in.ActorID = "" err := testClient.RegisterActorTimer(ctx, in) in.ActorID = "fn" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without Name ", func(t *testing.T) { in.Name = "" err := testClient.RegisterActorTimer(ctx, in) in.Name = "mockName" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without period ", func(t *testing.T) { in.Period = "" err := testClient.RegisterActorTimer(ctx, in) in.Period = "2s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor timer without dutTime ", func(t *testing.T) { in.DueTime = "" err := testClient.RegisterActorTimer(ctx, in) in.DueTime = "4s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor timer without TTL ", func(t *testing.T) { in.TTL = "" err := testClient.RegisterActorTimer(ctx, in) in.TTL = "20s" - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor timer without callBack ", func(t *testing.T) { in.CallBack = "" err := testClient.RegisterActorTimer(ctx, in) in.CallBack = "mockFunc" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without data ", func(t *testing.T) { in.Data = nil err := testClient.RegisterActorTimer(ctx, in) in.Data = []byte(`{hello}`) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke register actor timer", func(t *testing.T) { - assert.NoError(t, testClient.RegisterActorTimer(ctx, in)) + require.NoError(t, testClient.RegisterActorTimer(ctx, in)) }) t.Run("invoke register actor timer with empty param", func(t *testing.T) { - assert.Error(t, testClient.RegisterActorTimer(ctx, nil)) + require.Error(t, testClient.RegisterActorTimer(ctx, nil)) }) } @@ -224,36 +226,36 @@ func TestUnregisterActorReminder(t *testing.T) { in.ActorType = "" err := testClient.UnregisterActorReminder(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke unregister actor reminder without id ", func(t *testing.T) { in.ActorID = "" err := testClient.UnregisterActorReminder(ctx, in) in.ActorID = "fn" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke unregister actor reminder without Name ", func(t *testing.T) { in.Name = "" err := testClient.UnregisterActorReminder(ctx, in) in.Name = "mockName" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke unregister actor reminder without period ", func(t *testing.T) { in.ActorType = "" err := testClient.UnregisterActorReminder(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke unregister actor reminder ", func(t *testing.T) { - assert.NoError(t, testClient.UnregisterActorReminder(ctx, in)) + require.NoError(t, testClient.UnregisterActorReminder(ctx, in)) }) t.Run("invoke unregister actor reminder with empty param", func(t *testing.T) { - assert.Error(t, testClient.UnregisterActorReminder(ctx, nil)) + require.Error(t, testClient.UnregisterActorReminder(ctx, nil)) }) } @@ -269,35 +271,35 @@ func TestUnregisterActorTimer(t *testing.T) { in.ActorType = "" err := testClient.UnregisterActorTimer(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without id ", func(t *testing.T) { in.ActorID = "" err := testClient.UnregisterActorTimer(ctx, in) in.ActorID = "fn" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without Name ", func(t *testing.T) { in.Name = "" err := testClient.UnregisterActorTimer(ctx, in) in.Name = "mockName" - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer without period ", func(t *testing.T) { in.ActorType = "" err := testClient.UnregisterActorTimer(ctx, in) in.ActorType = testActorType - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke register actor timer ", func(t *testing.T) { - assert.NoError(t, testClient.UnregisterActorTimer(ctx, in)) + require.NoError(t, testClient.UnregisterActorTimer(ctx, in)) }) t.Run("invoke register actor timer with empty param", func(t *testing.T) { - assert.Error(t, testClient.UnregisterActorTimer(ctx, nil)) + require.Error(t, testClient.UnregisterActorTimer(ctx, nil)) }) } diff --git a/client/binding.go b/client/binding.go index 3acae37c..f06d7276 100644 --- a/client/binding.go +++ b/client/binding.go @@ -68,8 +68,8 @@ func (c *GRPCClient) InvokeBinding(ctx context.Context, in *InvokeBindingRequest if resp != nil { return &BindingEvent{ - Data: resp.Data, - Metadata: resp.Metadata, + Data: resp.GetData(), + Metadata: resp.GetMetadata(), }, nil } diff --git a/client/binding_test.go b/client/binding_test.go index adc6d6b6..aaeffbcf 100644 --- a/client/binding_test.go +++ b/client/binding_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -31,19 +33,19 @@ func TestInvokeBinding(t *testing.T) { t.Run("output binding without data", func(t *testing.T) { err := testClient.InvokeOutputBinding(ctx, in) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("output binding", func(t *testing.T) { in.Data = []byte("test") err := testClient.InvokeOutputBinding(ctx, in) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("binding without data", func(t *testing.T) { in.Data = nil out, err := testClient.InvokeBinding(ctx, in) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) @@ -51,7 +53,7 @@ func TestInvokeBinding(t *testing.T) { in.Data = []byte("test") in.Metadata = map[string]string{"k1": "v1", "k2": "v2"} out, err := testClient.InvokeBinding(ctx, in) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) assert.Equal(t, "test", string(out.Data)) }) diff --git a/client/client_test.go b/client/client_test.go index e5c10dbe..04d070ec 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -66,22 +66,22 @@ func TestMain(m *testing.M) { func TestNewClient(t *testing.T) { t.Run("return error when unable to reach server", func(t *testing.T) { _, err := NewClientWithPort("1") - assert.Error(t, err) + require.Error(t, err) }) t.Run("no arg for with port", func(t *testing.T) { _, err := NewClientWithPort("") - assert.Error(t, err) + require.Error(t, err) }) t.Run("no arg for with address", func(t *testing.T) { _, err := NewClientWithAddress("") - assert.Error(t, err) + require.Error(t, err) }) t.Run("no arg with socket", func(t *testing.T) { _, err := NewClientWithSocket("") - assert.Error(t, err) + require.Error(t, err) }) t.Run("new client closed with token", func(t *testing.T) { @@ -129,7 +129,7 @@ func TestShutdown(t *testing.T) { t.Run("shutdown", func(t *testing.T) { err := testClient.Shutdown(ctx) - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -201,33 +201,33 @@ func Test_getClientTimeoutSeconds(t *testing.T) { t.Run("empty env var", func(t *testing.T) { t.Setenv(clientTimeoutSecondsEnvVarName, "") got, err := getClientTimeoutSeconds() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, clientDefaultTimeoutSeconds, got) }) t.Run("invalid env var", func(t *testing.T) { t.Setenv(clientTimeoutSecondsEnvVarName, "invalid") _, err := getClientTimeoutSeconds() - assert.Error(t, err) + require.Error(t, err) }) t.Run("normal env var", func(t *testing.T) { t.Setenv(clientTimeoutSecondsEnvVarName, "7") got, err := getClientTimeoutSeconds() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, 7, got) }) t.Run("zero env var", func(t *testing.T) { t.Setenv(clientTimeoutSecondsEnvVarName, "0") _, err := getClientTimeoutSeconds() - assert.Error(t, err) + require.Error(t, err) }) t.Run("negative env var", func(t *testing.T) { t.Setenv(clientTimeoutSecondsEnvVarName, "-3") _, err := getClientTimeoutSeconds() - assert.Error(t, err) + require.Error(t, err) }) } @@ -251,7 +251,7 @@ func (s *testDaprServer) UnlockAlpha1(ctx context.Context, req *pb.UnlockRequest } func (s *testDaprServer) InvokeService(ctx context.Context, req *pb.InvokeServiceRequest) (*commonv1pb.InvokeResponse, error) { - if req.Message == nil { + if req.GetMessage() == nil { return &commonv1pb.InvokeResponse{ ContentType: "text/plain", Data: &anypb.Any{ @@ -260,14 +260,14 @@ func (s *testDaprServer) InvokeService(ctx context.Context, req *pb.InvokeServic }, nil } return &commonv1pb.InvokeResponse{ - ContentType: req.Message.ContentType, - Data: req.Message.Data, + ContentType: req.GetMessage().GetContentType(), + Data: req.GetMessage().GetData(), }, nil } func (s *testDaprServer) GetState(ctx context.Context, req *pb.GetStateRequest) (*pb.GetStateResponse, error) { return &pb.GetStateResponse{ - Data: s.state[req.Key], + Data: s.state[req.GetKey()], Etag: "1", }, nil } @@ -290,15 +290,15 @@ func (s *testDaprServer) GetBulkState(ctx context.Context, in *pb.GetBulkStateRe } func (s *testDaprServer) SaveState(ctx context.Context, req *pb.SaveStateRequest) (*empty.Empty, error) { - for _, item := range req.States { - s.state[item.Key] = item.Value + for _, item := range req.GetStates() { + s.state[item.GetKey()] = item.GetValue() } return &empty.Empty{}, nil } func (s *testDaprServer) QueryStateAlpha1(ctx context.Context, req *pb.QueryStateRequest) (*pb.QueryStateResponse, error) { var v map[string]interface{} - if err := json.Unmarshal([]byte(req.Query), &v); err != nil { + if err := json.Unmarshal([]byte(req.GetQuery()), &v); err != nil { return nil, err } @@ -306,19 +306,19 @@ func (s *testDaprServer) QueryStateAlpha1(ctx context.Context, req *pb.QueryStat Results: make([]*pb.QueryStateItem, 0, len(s.state)), } for key, value := range s.state { - ret.Results = append(ret.Results, &pb.QueryStateItem{Key: key, Data: value}) + ret.Results = append(ret.GetResults(), &pb.QueryStateItem{Key: key, Data: value}) } return ret, nil } func (s *testDaprServer) DeleteState(ctx context.Context, req *pb.DeleteStateRequest) (*empty.Empty, error) { - delete(s.state, req.Key) + delete(s.state, req.GetKey()) return &empty.Empty{}, nil } func (s *testDaprServer) DeleteBulkState(ctx context.Context, req *pb.DeleteBulkStateRequest) (*empty.Empty, error) { - for _, item := range req.States { - delete(s.state, item.Key) + for _, item := range req.GetStates() { + delete(s.state, item.GetKey()) } return &empty.Empty{}, nil } @@ -328,9 +328,9 @@ func (s *testDaprServer) ExecuteStateTransaction(ctx context.Context, in *pb.Exe item := op.GetRequest() switch opType := op.GetOperationType(); opType { case "upsert": - s.state[item.Key] = item.Value + s.state[item.GetKey()] = item.GetValue() case "delete": - delete(s.state, item.Key) + delete(s.state, item.GetKey()) default: return &empty.Empty{}, fmt.Errorf("invalid operation type: %s", opType) } @@ -362,14 +362,14 @@ func (s *testDaprServer) PublishEvent(ctx context.Context, req *pb.PublishEventR // It will fail the entire request if an event starts with "failall". func (s *testDaprServer) BulkPublishEventAlpha1(ctx context.Context, req *pb.BulkPublishRequest) (*pb.BulkPublishResponse, error) { failedEntries := make([]*pb.BulkPublishResponseFailedEntry, 0) - for _, entry := range req.Entries { - if bytes.HasPrefix(entry.Event, []byte("failall")) { + for _, entry := range req.GetEntries() { + if bytes.HasPrefix(entry.GetEvent(), []byte("failall")) { // fail the entire request return nil, errors.New("failed to publish events") - } else if bytes.HasPrefix(entry.Event, []byte("fail")) { + } else if bytes.HasPrefix(entry.GetEvent(), []byte("fail")) { // fail this entry failedEntries = append(failedEntries, &pb.BulkPublishResponseFailedEntry{ - EntryId: entry.EntryId, + EntryId: entry.GetEntryId(), Error: "failed to publish events", }) } @@ -378,15 +378,15 @@ func (s *testDaprServer) BulkPublishEventAlpha1(ctx context.Context, req *pb.Bul } func (s *testDaprServer) InvokeBinding(ctx context.Context, req *pb.InvokeBindingRequest) (*pb.InvokeBindingResponse, error) { - if req.Data == nil { + if req.GetData() == nil { return &pb.InvokeBindingResponse{ Data: []byte("test"), Metadata: map[string]string{"k1": "v1", "k2": "v2"}, }, nil } return &pb.InvokeBindingResponse{ - Data: req.Data, - Metadata: req.Metadata, + Data: req.GetData(), + Metadata: req.GetMetadata(), }, nil } @@ -491,12 +491,12 @@ func (s *testDaprServer) SubscribeConfiguration(in *pb.SubscribeConfigurationReq func (s *testDaprServer) UnsubscribeConfiguration(ctx context.Context, in *pb.UnsubscribeConfigurationRequest) (*pb.UnsubscribeConfigurationResponse, error) { s.configurationSubscriptionIDMapLoc.Lock() defer s.configurationSubscriptionIDMapLoc.Unlock() - ch, ok := s.configurationSubscriptionID[in.Id] + ch, ok := s.configurationSubscriptionID[in.GetId()] if !ok { return &pb.UnsubscribeConfigurationResponse{Ok: true}, nil } close(ch) - delete(s.configurationSubscriptionID, in.Id) + delete(s.configurationSubscriptionID, in.GetId()) return &pb.UnsubscribeConfigurationResponse{Ok: true}, nil } diff --git a/client/configuration.go b/client/configuration.go index bbdae219..b5344945 100644 --- a/client/configuration.go +++ b/client/configuration.go @@ -50,11 +50,11 @@ func (c *GRPCClient) GetConfigurationItems(ctx context.Context, storeName string } configItems := make(map[string]*ConfigurationItem) - for k, v := range rsp.Items { + for k, v := range rsp.GetItems() { configItems[k] = &ConfigurationItem{ - Value: v.Value, - Version: v.Version, - Metadata: v.Metadata, + Value: v.GetValue(), + Version: v.GetVersion(), + Metadata: v.GetMetadata(), } } return configItems, nil @@ -88,21 +88,21 @@ func (c *GRPCClient) SubscribeConfigurationItems(ctx context.Context, storeName } configurationItems := make(map[string]*ConfigurationItem) - for k, v := range rsp.Items { + for k, v := range rsp.GetItems() { configurationItems[k] = &ConfigurationItem{ - Value: v.Value, - Version: v.Version, - Metadata: v.Metadata, + Value: v.GetValue(), + Version: v.GetVersion(), + Metadata: v.GetMetadata(), } } // Get the subscription ID from the first response. if isFirst { - subscribeIDChan <- rsp.Id + subscribeIDChan <- rsp.GetId() isFirst = false } // Do not invoke handler in case there are no items. if len(configurationItems) > 0 { - handler(rsp.Id, configurationItems) + handler(rsp.GetId(), configurationItems) } } }() @@ -119,7 +119,7 @@ func (c *GRPCClient) UnsubscribeConfigurationItems(ctx context.Context, storeNam if err != nil { return fmt.Errorf("unsubscribe failed with error = %w", err) } - if !resp.Ok { + if !resp.GetOk() { return fmt.Errorf("unsubscribe error message = %s", resp.GetMessage()) } return nil diff --git a/client/configuration_test.go b/client/configuration_test.go index 338ba9b2..b90e193d 100644 --- a/client/configuration_test.go +++ b/client/configuration_test.go @@ -6,6 +6,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -18,13 +20,13 @@ func TestGetConfigurationItem(t *testing.T) { t.Run("get configuration item", func(t *testing.T) { resp, err := testClient.GetConfigurationItem(ctx, "example-config", "mykey") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, "mykey"+valueSuffix, resp.Value) }) t.Run("get configuration item with invalid storeName", func(t *testing.T) { _, err := testClient.GetConfigurationItem(ctx, "", "mykey") - assert.NotNil(t, err) + require.Error(t, err) }) } @@ -34,7 +36,7 @@ func TestGetConfigurationItems(t *testing.T) { keys := []string{"mykey1", "mykey2", "mykey3"} t.Run("Test get configuration items", func(t *testing.T) { resp, err := testClient.GetConfigurationItems(ctx, "example-config", keys) - assert.Nil(t, err) + require.NoError(t, err) for _, k := range keys { assert.Equal(t, k+valueSuffix, resp[k].Value) } @@ -57,7 +59,7 @@ func TestSubscribeConfigurationItems(t *testing.T) { atomic.AddUint32(&totalCounter, 1) } }) - assert.Nil(t, err) + require.NoError(t, err) }) time.Sleep(time.Second*5 + time.Millisecond*500) assert.Equal(t, uint32(5), atomic.LoadUint32(&counter)) @@ -78,11 +80,11 @@ func TestUnSubscribeConfigurationItems(t *testing.T) { atomic.AddUint32(&totalCounter, 1) } }) - assert.Nil(t, err) + require.NoError(t, err) time.Sleep(time.Second * 2) time.Sleep(time.Millisecond * 500) err = testClient.UnsubscribeConfigurationItems(ctx, "example-config", subscribeID) - assert.Nil(t, err) + require.NoError(t, err) }) time.Sleep(time.Second * 5) assert.Equal(t, uint32(3), atomic.LoadUint32(&counter)) diff --git a/client/crypto.go b/client/crypto.go index 9afc459a..41ffcf2d 100644 --- a/client/crypto.go +++ b/client/crypto.go @@ -186,13 +186,13 @@ func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.Cli // Write the data, if any, into the pipe payload = resProto.GetPayload() if payload != nil { - if payload.Seq != expectSeq { - pw.CloseWithError(fmt.Errorf("invalid sequence number in chunk: %d (expected: %d)", payload.Seq, expectSeq)) + if payload.GetSeq() != expectSeq { + pw.CloseWithError(fmt.Errorf("invalid sequence number in chunk: %d (expected: %d)", payload.GetSeq(), expectSeq)) return } expectSeq++ - _, readErr = pw.Write(payload.Data) + _, readErr = pw.Write(payload.GetData()) if readErr != nil { pw.CloseWithError(fmt.Errorf("error writing data: %w", readErr)) return diff --git a/client/crypto_test.go b/client/crypto_test.go index 04b509b0..46956f36 100644 --- a/client/crypto_test.go +++ b/client/crypto_test.go @@ -236,13 +236,13 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro payload := reqProto.GetPayload() if payload != nil { - if payload.Seq != expectSeq { - pw.CloseWithError(fmt.Errorf("invalid sequence number: %d (expected: %d)", payload.Seq, expectSeq)) + if payload.GetSeq() != expectSeq { + pw.CloseWithError(fmt.Errorf("invalid sequence number: %d (expected: %d)", payload.GetSeq(), expectSeq)) return } expectSeq++ - _, err = pw.Write(payload.Data) + _, err = pw.Write(payload.GetData()) if err != nil { pw.CloseWithError(err) return diff --git a/client/invoke.go b/client/invoke.go index fb9ce1c5..1a4fff3a 100644 --- a/client/invoke.go +++ b/client/invoke.go @@ -46,7 +46,7 @@ func (c *GRPCClient) invokeServiceWithRequest(ctx context.Context, req *pb.Invok // allow for service to not return any value if resp != nil && resp.GetData() != nil { - out = resp.GetData().Value + out = resp.GetData().GetValue() return } diff --git a/client/invoke_test.go b/client/invoke_test.go index 6fefb5f3..3a8b769b 100644 --- a/client/invoke_test.go +++ b/client/invoke_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" v1 "github.com/dapr/dapr/pkg/proto/common/v1" @@ -46,7 +48,7 @@ func TestInvokeMethodWithContent(t *testing.T) { Data: []byte(data), } resp, err := testClient.InvokeMethodWithContent(ctx, "test", "fn", "post", content) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, resp) assert.Equal(t, string(resp), data) }) @@ -57,28 +59,28 @@ func TestInvokeMethodWithContent(t *testing.T) { Data: []byte(data), } resp, err := testClient.InvokeMethodWithContent(ctx, "test", "fn?foo=bar&url=http://dapr.io", "get", content) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, resp) assert.Equal(t, string(resp), data) }) t.Run("without content", func(t *testing.T) { resp, err := testClient.InvokeMethod(ctx, "test", "fn", "get") - assert.Nil(t, err) + require.NoError(t, err) assert.Nil(t, resp) }) t.Run("without service ID", func(t *testing.T) { _, err := testClient.InvokeMethod(ctx, "", "fn", "get") - assert.NotNil(t, err) + require.Error(t, err) }) t.Run("without method", func(t *testing.T) { _, err := testClient.InvokeMethod(ctx, "test", "", "get") - assert.NotNil(t, err) + require.Error(t, err) }) t.Run("without verb", func(t *testing.T) { _, err := testClient.InvokeMethod(ctx, "test", "fn", "") - assert.NotNil(t, err) + require.Error(t, err) }) t.Run("from struct with text", func(t *testing.T) { testdata := _testCustomContentwithText{ @@ -86,7 +88,7 @@ func TestInvokeMethodWithContent(t *testing.T) { Key2: "value2", } _, err := testClient.InvokeMethodWithCustomContent(ctx, "test", "fn", "post", "text/plain", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("from struct with text and numbers", func(t *testing.T) { @@ -95,7 +97,7 @@ func TestInvokeMethodWithContent(t *testing.T) { Key2: 2500, } _, err := testClient.InvokeMethodWithCustomContent(ctx, "test", "fn", "post", "text/plain", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("from struct with slices", func(t *testing.T) { @@ -104,7 +106,7 @@ func TestInvokeMethodWithContent(t *testing.T) { Key2: []int{25, 40, 600}, } _, err := testClient.InvokeMethodWithCustomContent(ctx, "test", "fn", "post", "text/plain", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) } @@ -112,27 +114,27 @@ func TestVerbParsing(t *testing.T) { t.Run("valid lower case", func(t *testing.T) { v := queryAndVerbToHTTPExtension("", "post") assert.NotNil(t, v) - assert.Equal(t, v1.HTTPExtension_POST, v.Verb) - assert.Len(t, v.Querystring, 0) + assert.Equal(t, v1.HTTPExtension_POST, v.GetVerb()) + assert.Empty(t, v.GetQuerystring()) }) t.Run("valid upper case", func(t *testing.T) { v := queryAndVerbToHTTPExtension("", "GET") assert.NotNil(t, v) - assert.Equal(t, v1.HTTPExtension_GET, v.Verb) + assert.Equal(t, v1.HTTPExtension_GET, v.GetVerb()) }) t.Run("invalid verb", func(t *testing.T) { v := queryAndVerbToHTTPExtension("", "BAD") assert.NotNil(t, v) - assert.Equal(t, v1.HTTPExtension_NONE, v.Verb) + assert.Equal(t, v1.HTTPExtension_NONE, v.GetVerb()) }) t.Run("valid query", func(t *testing.T) { v := queryAndVerbToHTTPExtension("foo=bar&url=http://dapr.io", "post") assert.NotNil(t, v) - assert.Equal(t, v1.HTTPExtension_POST, v.Verb) - assert.Equal(t, "foo=bar&url=http://dapr.io", v.Querystring) + assert.Equal(t, v1.HTTPExtension_POST, v.GetVerb()) + assert.Equal(t, "foo=bar&url=http://dapr.io", v.GetQuerystring()) }) } diff --git a/client/lock.go b/client/lock.go index 26bc226a..26ca8614 100644 --- a/client/lock.go +++ b/client/lock.go @@ -68,7 +68,7 @@ func (c *GRPCClient) TryLockAlpha1(ctx context.Context, storeName string, reques } return &LockResponse{ - Success: resp.Success, + Success: resp.GetSuccess(), }, nil } @@ -94,7 +94,7 @@ func (c *GRPCClient) UnlockAlpha1(ctx context.Context, storeName string, request } return &UnlockResponse{ - StatusCode: int32(resp.Status), - Status: pb.UnlockResponse_Status_name[int32(resp.Status)], + StatusCode: int32(resp.GetStatus()), + Status: pb.UnlockResponse_Status_name[int32(resp.GetStatus())], }, nil } diff --git a/client/lock_test.go b/client/lock_test.go index eaf1b035..86d0acdc 100644 --- a/client/lock_test.go +++ b/client/lock_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" pb "github.com/dapr/dapr/pkg/proto/runtime/v1" @@ -32,13 +34,13 @@ func TestLock(t *testing.T) { t.Run("try lock invalid store name", func(t *testing.T) { r, err := testClient.TryLockAlpha1(ctx, "", &LockRequest{}) assert.Nil(t, r) - assert.Error(t, err) + require.Error(t, err) }) t.Run("try lock invalid request", func(t *testing.T) { r, err := testClient.TryLockAlpha1(ctx, testLockStore, nil) assert.Nil(t, r) - assert.Error(t, err) + require.Error(t, err) }) t.Run("try lock", func(t *testing.T) { @@ -48,7 +50,7 @@ func TestLock(t *testing.T) { ExpiryInSeconds: 5, }) assert.NotNil(t, r) - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, r.Success) }) @@ -58,13 +60,13 @@ func TestLock(t *testing.T) { ResourceID: "resource1", }) assert.Nil(t, r) - assert.Error(t, err) + require.Error(t, err) }) t.Run("unlock invalid request", func(t *testing.T) { r, err := testClient.UnlockAlpha1(ctx, "testLockStore", nil) assert.Nil(t, r) - assert.Error(t, err) + require.Error(t, err) }) t.Run("unlock", func(t *testing.T) { @@ -73,7 +75,7 @@ func TestLock(t *testing.T) { ResourceID: "resource1", }) assert.NotNil(t, r) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, pb.UnlockResponse_SUCCESS.String(), r.Status) }) } diff --git a/client/metadata.go b/client/metadata.go index 1d1c46e2..151c66ac 100644 --- a/client/metadata.go +++ b/client/metadata.go @@ -57,48 +57,48 @@ func (c *GRPCClient) GetMetadata(ctx context.Context) (metadata *GetMetadataResp return nil, fmt.Errorf("error invoking service: %w", err) } if resp != nil { - activeActorsCount := make([]*MetadataActiveActorsCount, len(resp.ActiveActorsCount)) - for a := range resp.ActiveActorsCount { - activeActorsCount[a] = &MetadataActiveActorsCount{ - Type: resp.ActiveActorsCount[a].Type, - Count: resp.ActiveActorsCount[a].Count, + activeActorsCount := make([]*MetadataActiveActorsCount, len(resp.GetActiveActorsCount())) + for i, a := range resp.GetActiveActorsCount() { + activeActorsCount[i] = &MetadataActiveActorsCount{ + Type: a.GetType(), + Count: a.GetCount(), } } - registeredComponents := make([]*MetadataRegisteredComponents, len(resp.RegisteredComponents)) - for r := range resp.RegisteredComponents { - registeredComponents[r] = &MetadataRegisteredComponents{ - Name: resp.RegisteredComponents[r].Name, - Type: resp.RegisteredComponents[r].Type, - Version: resp.RegisteredComponents[r].Version, - Capabilities: resp.RegisteredComponents[r].Capabilities, + registeredComponents := make([]*MetadataRegisteredComponents, len(resp.GetRegisteredComponents())) + for i, r := range resp.GetRegisteredComponents() { + registeredComponents[i] = &MetadataRegisteredComponents{ + Name: r.GetName(), + Type: r.GetType(), + Version: r.GetVersion(), + Capabilities: r.GetCapabilities(), } } - subscriptions := make([]*MetadataSubscription, len(resp.Subscriptions)) - for s := range resp.Subscriptions { + subscriptions := make([]*MetadataSubscription, len(resp.GetSubscriptions())) + for i, s := range resp.GetSubscriptions() { rules := &PubsubSubscriptionRules{} - for r := range resp.Subscriptions[s].Rules.Rules { + for _, r := range s.GetRules().GetRules() { rules.Rules = append(rules.Rules, &PubsubSubscriptionRule{ - Match: resp.Subscriptions[s].Rules.Rules[r].Match, - Path: resp.Subscriptions[s].Rules.Rules[r].Path, + Match: r.GetMatch(), + Path: r.GetPath(), }) } - subscriptions[s] = &MetadataSubscription{ - PubsubName: resp.Subscriptions[s].PubsubName, - Topic: resp.Subscriptions[s].Topic, - Metadata: resp.Subscriptions[s].Metadata, + subscriptions[i] = &MetadataSubscription{ + PubsubName: s.GetPubsubName(), + Topic: s.GetTopic(), + Metadata: s.GetMetadata(), Rules: rules, - DeadLetterTopic: resp.Subscriptions[s].DeadLetterTopic, + DeadLetterTopic: s.GetDeadLetterTopic(), } } - httpEndpoints := make([]*MetadataHTTPEndpoint, len(resp.HttpEndpoints)) - for e := range resp.HttpEndpoints { - httpEndpoints[e] = &MetadataHTTPEndpoint{ - Name: resp.HttpEndpoints[e].Name, + httpEndpoints := make([]*MetadataHTTPEndpoint, len(resp.GetHttpEndpoints())) + for i, e := range resp.GetHttpEndpoints() { + httpEndpoints[i] = &MetadataHTTPEndpoint{ + Name: e.GetName(), } } metadata = &GetMetadataResponse{ - ID: resp.Id, + ID: resp.GetId(), ActiveActorsCount: activeActorsCount, RegisteredComponents: registeredComponents, ExtendedMetadata: resp.GetExtendedMetadata(), diff --git a/client/metadata_test.go b/client/metadata_test.go index a2da3805..fa34e6fd 100644 --- a/client/metadata_test.go +++ b/client/metadata_test.go @@ -4,6 +4,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -12,7 +14,7 @@ func TestGetMetadata(t *testing.T) { ctx := context.Background() t.Run("get meta", func(t *testing.T) { metadata, err := testClient.GetMetadata(ctx) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, metadata) }) } @@ -21,9 +23,9 @@ func TestSetMetadata(t *testing.T) { ctx := context.Background() t.Run("set meta", func(t *testing.T) { err := testClient.SetMetadata(ctx, "test_key", "test_value") - assert.NoError(t, err) + require.NoError(t, err) metadata, err := testClient.GetMetadata(ctx) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "test_value", metadata.ExtendedMetadata["test_key"]) }) } diff --git a/client/pubsub.go b/client/pubsub.go index 6e5a83d2..3996c32e 100644 --- a/client/pubsub.go +++ b/client/pubsub.go @@ -91,7 +91,7 @@ func PublishEventWithMetadata(metadata map[string]string) PublishEventOption { // PublishEventWithRawPayload can be passed as option to PublishEvent to set rawPayload metadata. func PublishEventWithRawPayload() PublishEventOption { return func(e *pb.PublishEventRequest) { - if e.Metadata == nil { + if e.GetMetadata() == nil { e.Metadata = map[string]string{rawPayload: trueValue} } else { e.Metadata[rawPayload] = trueValue @@ -156,7 +156,7 @@ func (c *GRPCClient) PublishEvents(ctx context.Context, pubsubName, topicName st failedEvents = append(failedEvents, event) continue } - eventMap[entry.EntryId] = event + eventMap[entry.GetEntryId()] = event entries = append(entries, entry) } @@ -178,11 +178,11 @@ func (c *GRPCClient) PublishEvents(ctx context.Context, pubsubName, topicName st } } - for _, failedEntry := range res.FailedEntries { - event, ok := eventMap[failedEntry.EntryId] + for _, failedEntry := range res.GetFailedEntries() { + event, ok := eventMap[failedEntry.GetEntryId()] if !ok { // This should never happen. - failedEvents = append(failedEvents, failedEntry.EntryId) + failedEvents = append(failedEvents, failedEntry.GetEntryId()) } failedEvents = append(failedEvents, event) } @@ -224,12 +224,12 @@ func createBulkPublishRequestEntry(data interface{}) (*pb.BulkPublishRequestEntr return &pb.BulkPublishRequestEntry{}, fmt.Errorf("error serializing input struct: %w", err) } - if isCloudEvent(entry.Event) { + if isCloudEvent(entry.GetEvent()) { entry.ContentType = "application/cloudevents+json" } } - if entry.EntryId == "" { + if entry.GetEntryId() == "" { entry.EntryId = uuid.New().String() } @@ -239,7 +239,7 @@ func createBulkPublishRequestEntry(data interface{}) (*pb.BulkPublishRequestEntr // PublishEventsWithContentType can be passed as option to PublishEvents to explicitly set the same Content-Type for all events. func PublishEventsWithContentType(contentType string) PublishEventsOption { return func(r *pb.BulkPublishRequest) { - for _, entry := range r.Entries { + for _, entry := range r.GetEntries() { entry.ContentType = contentType } } @@ -255,7 +255,7 @@ func PublishEventsWithMetadata(metadata map[string]string) PublishEventsOption { // PublishEventsWithRawPayload can be passed as option to PublishEvents to set rawPayload request metadata. func PublishEventsWithRawPayload() PublishEventsOption { return func(r *pb.BulkPublishRequest) { - if r.Metadata == nil { + if r.GetMetadata() == nil { r.Metadata = map[string]string{rawPayload: trueValue} } else { r.Metadata[rawPayload] = trueValue diff --git a/client/pubsub_test.go b/client/pubsub_test.go index dbcfb3eb..56db1357 100644 --- a/client/pubsub_test.go +++ b/client/pubsub_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/google/uuid" "github.com/stretchr/testify/assert" ) @@ -41,17 +43,17 @@ func TestPublishEvent(t *testing.T) { t.Run("with data", func(t *testing.T) { err := testClient.PublishEvent(ctx, "messages", "test", []byte("ping")) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("without data", func(t *testing.T) { err := testClient.PublishEvent(ctx, "messages", "test", nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("with empty topic name", func(t *testing.T) { err := testClient.PublishEvent(ctx, "messages", "", []byte("ping")) - assert.NotNil(t, err) + require.Error(t, err) }) t.Run("from struct with text", func(t *testing.T) { @@ -60,7 +62,7 @@ func TestPublishEvent(t *testing.T) { Key2: "value2", } err := testClient.PublishEventfromCustomContent(ctx, "messages", "test", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("from struct with text and numbers", func(t *testing.T) { @@ -69,7 +71,7 @@ func TestPublishEvent(t *testing.T) { Key2: 2500, } err := testClient.PublishEventfromCustomContent(ctx, "messages", "test", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("from struct with slices", func(t *testing.T) { @@ -78,17 +80,17 @@ func TestPublishEvent(t *testing.T) { Key2: []int{25, 40, 600}, } err := testClient.PublishEventfromCustomContent(ctx, "messages", "test", testdata) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("error serializing JSON", func(t *testing.T) { err := testClient.PublishEventfromCustomContent(ctx, "messages", "test", make(chan struct{})) - assert.Error(t, err) + require.Error(t, err) }) t.Run("raw payload", func(t *testing.T) { err := testClient.PublishEvent(ctx, "messages", "test", []byte("ping"), PublishEventWithRawPayload()) - assert.Nil(t, err) + require.NoError(t, err) }) } @@ -98,7 +100,7 @@ func TestPublishEvents(t *testing.T) { t.Run("without pubsub name", func(t *testing.T) { res := testClient.PublishEvents(ctx, "", "test", []interface{}{"ping", "pong"}) - assert.Error(t, res.Error) + require.Error(t, res.Error) assert.Len(t, res.FailedEvents, 2) assert.Contains(t, res.FailedEvents, "ping") assert.Contains(t, res.FailedEvents, "pong") @@ -106,7 +108,7 @@ func TestPublishEvents(t *testing.T) { t.Run("without topic name", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "", []interface{}{"ping", "pong"}) - assert.Error(t, res.Error) + require.Error(t, res.Error) assert.Len(t, res.FailedEvents, 2) assert.Contains(t, res.FailedEvents, "ping") assert.Contains(t, res.FailedEvents, "pong") @@ -114,14 +116,14 @@ func TestPublishEvents(t *testing.T) { t.Run("with data", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong"}) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) t.Run("without data", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", nil) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) t.Run("with struct data", func(t *testing.T) { @@ -155,47 +157,47 @@ func TestPublishEvents(t *testing.T) { for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{tc.data}) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) } }) t.Run("error serializing one event", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{make(chan struct{}), "pong"}) - assert.Error(t, res.Error) + require.Error(t, res.Error) assert.Len(t, res.FailedEvents, 1) assert.IsType(t, make(chan struct{}), res.FailedEvents[0]) }) t.Run("with raw payload", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong"}, PublishEventsWithRawPayload()) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) t.Run("with metadata", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong"}, PublishEventsWithMetadata(map[string]string{"key": "value"})) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) t.Run("with custom content type", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong"}, PublishEventsWithContentType("text/plain")) - assert.Nil(t, res.Error) - assert.Len(t, res.FailedEvents, 0) + require.NoError(t, res.Error) + assert.Empty(t, res.FailedEvents) }) t.Run("with events that will fail some events", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong", "fail-ping"}) - assert.Error(t, res.Error) + require.Error(t, res.Error) assert.Len(t, res.FailedEvents, 1) assert.Contains(t, res.FailedEvents, "fail-ping") }) t.Run("with events that will fail the entire request", func(t *testing.T) { res := testClient.PublishEvents(ctx, "messages", "test", []interface{}{"ping", "pong", "failall-ping"}) - assert.Error(t, res.Error) + require.Error(t, res.Error) assert.Len(t, res.FailedEvents, 3) assert.Contains(t, res.FailedEvents, "ping") assert.Contains(t, res.FailedEvents, "pong") @@ -275,11 +277,11 @@ func TestCreateBulkPublishRequestEntry(t *testing.T) { t.Run(tc.name, func(t *testing.T) { entry, err := createBulkPublishRequestEntry(tc.data) if tc.expectedError { - assert.Error(t, err) + require.Error(t, err) } else { - assert.Nil(t, err) - assert.Equal(t, tc.expectedEvent, entry.Event) - assert.Equal(t, tc.expectedContentType, entry.ContentType) + require.NoError(t, err) + assert.Equal(t, tc.expectedEvent, entry.GetEvent()) + assert.Equal(t, tc.expectedContentType, entry.GetContentType()) } }) } @@ -292,9 +294,9 @@ func TestCreateBulkPublishRequestEntry(t *testing.T) { EntryID: "123", Metadata: map[string]string{"key": "value"}, }) - assert.Nil(t, err) - assert.Equal(t, "123", entry.EntryId) - assert.Equal(t, map[string]string{"key": "value"}, entry.Metadata) + require.NoError(t, err) + assert.Equal(t, "123", entry.GetEntryId()) + assert.Equal(t, map[string]string{"key": "value"}, entry.GetMetadata()) }) t.Run("should set random uuid as entryID when not provided", func(t *testing.T) { @@ -318,12 +320,12 @@ func TestCreateBulkPublishRequestEntry(t *testing.T) { for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { entry, err := createBulkPublishRequestEntry(tc.data) - assert.Nil(t, err) - assert.NotEmpty(t, entry.EntryId) - assert.Nil(t, entry.Metadata) + require.NoError(t, err) + assert.NotEmpty(t, entry.GetEntryId()) + assert.Nil(t, entry.GetMetadata()) - _, err = uuid.Parse(entry.EntryId) - assert.Nil(t, err) + _, err = uuid.Parse(entry.GetEntryId()) + require.NoError(t, err) }) } }) diff --git a/client/secret.go b/client/secret.go index dae2c63c..d5a90814 100644 --- a/client/secret.go +++ b/client/secret.go @@ -67,10 +67,10 @@ func (c *GRPCClient) GetBulkSecret(ctx context.Context, storeName string, meta m if resp != nil { data = map[string]map[string]string{} - for secretName, secretResponse := range resp.Data { + for secretName, secretResponse := range resp.GetData() { data[secretName] = map[string]string{} - for k, v := range secretResponse.Secrets { + for k, v := range secretResponse.GetSecrets() { data[secretName][k] = v } } diff --git a/client/secret_test.go b/client/secret_test.go index ab0b1a7f..94047f9f 100644 --- a/client/secret_test.go +++ b/client/secret_test.go @@ -17,6 +17,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -26,26 +28,26 @@ func TestGetSecret(t *testing.T) { t.Run("without store", func(t *testing.T) { out, err := testClient.GetSecret(ctx, "", "key1", nil) - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) t.Run("without key", func(t *testing.T) { out, err := testClient.GetSecret(ctx, "store", "", nil) - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) t.Run("without meta", func(t *testing.T) { out, err := testClient.GetSecret(ctx, "store", "key1", nil) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) t.Run("with meta", func(t *testing.T) { in := map[string]string{"k1": "v1", "k2": "v2"} out, err := testClient.GetSecret(ctx, "store", "key1", in) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) } @@ -55,20 +57,20 @@ func TestGetBulkSecret(t *testing.T) { t.Run("without store", func(t *testing.T) { out, err := testClient.GetBulkSecret(ctx, "", nil) - assert.Error(t, err) + require.Error(t, err) assert.Nil(t, out) }) t.Run("without meta", func(t *testing.T) { out, err := testClient.GetBulkSecret(ctx, "store", nil) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) t.Run("with meta", func(t *testing.T) { in := map[string]string{"k1": "v1", "k2": "v2"} out, err := testClient.GetBulkSecret(ctx, "store", in) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) } diff --git a/client/state.go b/client/state.go index b2ed44c1..42dcec42 100644 --- a/client/state.go +++ b/client/state.go @@ -87,10 +87,10 @@ func (o OperationType) String() string { func (s StateConsistency) String() string { names := [...]string{ UndefinedType, - "strong", "eventual", + "strong", } - if s < StateConsistencyStrong || s > StateConsistencyEventual { + if s < StateConsistencyEventual || s > StateConsistencyStrong { return UndefinedType } @@ -317,7 +317,7 @@ func (c *GRPCClient) SaveBulkState(ctx context.Context, storeName string, items for _, si := range items { item := toProtoSaveStateItem(si) - req.States = append(req.States, item) + req.States = append(req.GetStates(), item) } _, err := c.protoClient.SaveState(c.withAuthToken(ctx), req) @@ -349,17 +349,17 @@ func (c *GRPCClient) GetBulkState(ctx context.Context, storeName string, keys [] return nil, fmt.Errorf("error getting state: %w", err) } - if results == nil || results.Items == nil { + if results == nil || results.GetItems() == nil { return items, nil } - for _, r := range results.Items { + for _, r := range results.GetItems() { item := &BulkStateItem{ - Key: r.Key, - Etag: r.Etag, - Value: r.Data, - Metadata: r.Metadata, - Error: r.Error, + Key: r.GetKey(), + Etag: r.GetEtag(), + Value: r.GetData(), + Metadata: r.GetMetadata(), + Error: r.GetError(), } items = append(items, item) } @@ -391,10 +391,10 @@ func (c *GRPCClient) GetStateWithConsistency(ctx context.Context, storeName, key } return &StateItem{ - Etag: result.Etag, + Etag: result.GetEtag(), Key: key, - Value: result.Data, - Metadata: result.Metadata, + Value: result.GetData(), + Metadata: result.GetMetadata(), }, nil } @@ -417,15 +417,15 @@ func (c *GRPCClient) QueryStateAlpha1(ctx context.Context, storeName, query stri } ret := &QueryResponse{ - Results: make([]QueryItem, len(resp.Results)), - Token: resp.Token, - Metadata: resp.Metadata, - } - for i, item := range resp.Results { - ret.Results[i].Key = item.Key - ret.Results[i].Value = item.Data - ret.Results[i].Etag = item.Etag - ret.Results[i].Error = item.Error + Results: make([]QueryItem, len(resp.GetResults())), + Token: resp.GetToken(), + Metadata: resp.GetMetadata(), + } + for i, item := range resp.GetResults() { + ret.Results[i].Key = item.GetKey() + ret.Results[i].Value = item.GetData() + ret.Results[i].Etag = item.GetEtag() + ret.Results[i].Error = item.GetError() } return ret, nil diff --git a/client/state_test.go b/client/state_test.go index 34479a0e..c792d011 100644 --- a/client/state_test.go +++ b/client/state_test.go @@ -18,6 +18,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" v1 "github.com/dapr/dapr/pkg/proto/common/v1" @@ -29,19 +31,31 @@ const ( ) func TestTypes(t *testing.T) { - var op OperationType = -1 - assert.Equal(t, UndefinedType, op.String()) - var c StateConcurrency = -1 - assert.Equal(t, UndefinedType, c.String()) - var d StateConsistency = -1 - assert.Equal(t, UndefinedType, d.String()) + t.Run("test operation types", func(t *testing.T) { + var a OperationType = -1 + assert.Equal(t, UndefinedType, a.String()) + a = 2 + assert.Equal(t, "delete", a.String()) + }) + t.Run("test state concurrency type", func(t *testing.T) { + var b StateConcurrency = -1 + assert.Equal(t, UndefinedType, b.String()) + b = 2 + assert.Equal(t, "last-write", b.String()) + }) + t.Run("test state consistency type", func(t *testing.T) { + var c StateConsistency = -1 + assert.Equal(t, UndefinedType, c.String()) + c = 2 + assert.Equal(t, "strong", c.String()) + }) } func TestDurationConverter(t *testing.T) { d := 10 * time.Second pd := toProtoDuration(d) assert.NotNil(t, pd) - assert.Equal(t, pd.Seconds, int64(10)) + assert.Equal(t, int64(10), pd.GetSeconds()) } func TestStateOptionsConverter(t *testing.T) { @@ -51,8 +65,8 @@ func TestStateOptionsConverter(t *testing.T) { } p := toProtoStateOptions(s) assert.NotNil(t, p) - assert.Equal(t, p.Concurrency, v1.StateOptions_CONCURRENCY_LAST_WRITE) - assert.Equal(t, p.Consistency, v1.StateOptions_CONSISTENCY_STRONG) + assert.Equal(t, v1.StateOptions_CONCURRENCY_LAST_WRITE, p.GetConcurrency()) + assert.Equal(t, v1.StateOptions_CONSISTENCY_STRONG, p.GetConsistency()) } // go test -timeout 30s ./client -count 1 -run ^TestSaveState$ @@ -64,12 +78,12 @@ func TestSaveState(t *testing.T) { t.Run("save data", func(t *testing.T) { err := testClient.SaveState(ctx, store, key, []byte(data), nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("get saved data", func(t *testing.T) { item, err := testClient.GetState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -78,7 +92,7 @@ func TestSaveState(t *testing.T) { t.Run("get saved data with consistency", func(t *testing.T) { item, err := testClient.GetStateWithConsistency(ctx, store, key, nil, StateConsistencyStrong) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -87,12 +101,12 @@ func TestSaveState(t *testing.T) { t.Run("save data with version", func(t *testing.T) { err := testClient.SaveStateWithETag(ctx, store, key, []byte(data), "1", nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("delete data", func(t *testing.T) { err := testClient.DeleteState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) }) } @@ -105,21 +119,21 @@ func TestDeleteState(t *testing.T) { t.Run("delete not exist data", func(t *testing.T) { err := testClient.DeleteState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("delete not exist data with etag and meta", func(t *testing.T) { err := testClient.DeleteStateWithETag(ctx, store, key, &ETag{Value: "100"}, map[string]string{"meta1": "value1"}, &StateOptions{Concurrency: StateConcurrencyFirstWrite, Consistency: StateConsistencyEventual}) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("save data", func(t *testing.T) { err := testClient.SaveState(ctx, store, key, []byte(data), nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("confirm data saved", func(t *testing.T) { item, err := testClient.GetState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -128,11 +142,11 @@ func TestDeleteState(t *testing.T) { t.Run("delete exist data", func(t *testing.T) { err := testClient.DeleteState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("confirm data deleted", func(t *testing.T) { item, err := testClient.GetState(ctx, store, key, nil) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -142,11 +156,11 @@ func TestDeleteState(t *testing.T) { t.Run("save data again with etag, meta", func(t *testing.T) { meta := map[string]string{"meta1": "value1"} err := testClient.SaveStateWithETag(ctx, store, key, []byte(data), "1", meta, WithConsistency(StateConsistencyEventual), WithConcurrency(StateConcurrencyFirstWrite)) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("confirm data saved", func(t *testing.T) { item, err := testClient.GetStateWithConsistency(ctx, store, key, map[string]string{"meta1": "value1"}, StateConsistencyEventual) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -156,11 +170,11 @@ func TestDeleteState(t *testing.T) { t.Run("delete exist data with etag and meta", func(t *testing.T) { err := testClient.DeleteStateWithETag(ctx, store, key, &ETag{Value: "100"}, map[string]string{"meta1": "value1"}, &StateOptions{Concurrency: StateConcurrencyFirstWrite, Consistency: StateConsistencyEventual}) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("confirm data deleted", func(t *testing.T) { item, err := testClient.GetStateWithConsistency(ctx, store, key, map[string]string{"meta1": "value1"}, StateConsistencyEventual) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, item) assert.NotEmpty(t, item.Etag) assert.Equal(t, item.Key, key) @@ -176,7 +190,7 @@ func TestDeleteBulkState(t *testing.T) { t.Run("delete not exist data", func(t *testing.T) { err := testClient.DeleteBulkState(ctx, store, keys, nil) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("delete not exist data with stateIem", func(t *testing.T) { @@ -192,7 +206,48 @@ func TestDeleteBulkState(t *testing.T) { }) } err := testClient.DeleteBulkStateItems(ctx, store, items) - assert.Nil(t, err) + require.NoError(t, err) + }) + + t.Run("delete bulk state item (empty) store", func(t *testing.T) { // save data + // save data + items := make([]*SetStateItem, 0, len(keys)) + for _, key := range keys { + items = append(items, &SetStateItem{ + Key: key, + Value: []byte(data), + Metadata: map[string]string{}, + Etag: &ETag{Value: "1"}, + Options: &StateOptions{ + Concurrency: StateConcurrencyFirstWrite, + Consistency: StateConsistencyEventual, + }, + }) + } + err := testClient.SaveBulkState(ctx, store, items...) + require.NoError(t, err) + + // confirm data saved + getItems, err := testClient.GetBulkState(ctx, store, keys, nil, 1) + require.NoError(t, err) + assert.Equal(t, len(keys), len(getItems)) + + // delete + deleteItems := make([]*DeleteStateItem, 0, len(keys)) + for _, key := range keys { + deleteItems = append(deleteItems, &DeleteStateItem{ + Key: key, + Metadata: map[string]string{}, + Etag: &ETag{Value: "1"}, + Options: &StateOptions{ + Concurrency: StateConcurrencyFirstWrite, + Consistency: StateConsistencyEventual, + }, + }) + } + + err = testClient.DeleteBulkStateItems(ctx, "", deleteItems) + require.Error(t, err) }) t.Run("delete exist data", func(t *testing.T) { @@ -211,21 +266,21 @@ func TestDeleteBulkState(t *testing.T) { }) } err := testClient.SaveBulkState(ctx, store, items...) - assert.Nil(t, err) + require.NoError(t, err) // confirm data saved getItems, err := testClient.GetBulkState(ctx, store, keys, nil, 1) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, len(keys), len(getItems)) // delete err = testClient.DeleteBulkState(ctx, store, keys, nil) - assert.NoError(t, err) + require.NoError(t, err) // confirm data deleted getItems, err = testClient.GetBulkState(ctx, store, keys, nil, 1) - assert.NoError(t, err) - assert.Equal(t, 0, len(getItems)) + require.NoError(t, err) + assert.Empty(t, getItems) }) t.Run("delete exist data with stateItem", func(t *testing.T) { @@ -244,11 +299,11 @@ func TestDeleteBulkState(t *testing.T) { }) } err := testClient.SaveBulkState(ctx, store, items...) - assert.Nil(t, err) + require.NoError(t, err) // confirm data saved getItems, err := testClient.GetBulkState(ctx, store, keys, nil, 1) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, len(keys), len(getItems)) // delete @@ -265,12 +320,12 @@ func TestDeleteBulkState(t *testing.T) { }) } err = testClient.DeleteBulkStateItems(ctx, store, deleteItems) - assert.Nil(t, err) + require.NoError(t, err) // confirm data deleted getItems, err = testClient.GetBulkState(ctx, store, keys, nil, 1) - assert.NoError(t, err) - assert.Equal(t, 0, len(getItems)) + require.NoError(t, err) + assert.Empty(t, getItems) }) } @@ -296,16 +351,16 @@ func TestStateTransactions(t *testing.T) { t.Run("exec inserts", func(t *testing.T) { err := testClient.ExecuteStateTransaction(ctx, store, meta, adds) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("exec upserts", func(t *testing.T) { items, err := testClient.GetBulkState(ctx, store, keys, nil, 10) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, items) assert.Len(t, items, len(keys)) - upsers := make([]*StateOperation, 0) + upserts := make([]*StateOperation, 0) for _, item := range items { op := &StateOperation{ Type: StateOperationTypeUpsert, @@ -317,15 +372,15 @@ func TestStateTransactions(t *testing.T) { Value: item.Value, }, } - upsers = append(upsers, op) + upserts = append(upserts, op) } - err = testClient.ExecuteStateTransaction(ctx, store, meta, upsers) - assert.Nil(t, err) + err = testClient.ExecuteStateTransaction(ctx, store, meta, upserts) + require.NoError(t, err) }) t.Run("get and validate inserts", func(t *testing.T) { items, err := testClient.GetBulkState(ctx, store, keys, nil, 10) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, items) assert.Len(t, items, len(keys)) assert.Equal(t, data, string(items[0].Value)) @@ -337,14 +392,14 @@ func TestStateTransactions(t *testing.T) { t.Run("exec deletes", func(t *testing.T) { err := testClient.ExecuteStateTransaction(ctx, store, meta, adds) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("ensure deletes", func(t *testing.T) { items, err := testClient.GetBulkState(ctx, store, keys, nil, 3) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, items) - assert.Len(t, items, 0) + assert.Empty(t, items) }) } @@ -357,28 +412,39 @@ func TestQueryState(t *testing.T) { t.Run("save data", func(t *testing.T) { err := testClient.SaveState(ctx, store, key1, []byte(data), nil) - assert.NoError(t, err) + require.NoError(t, err) err = testClient.SaveState(ctx, store, key2, []byte(data), nil) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("error query", func(t *testing.T) { _, err := testClient.QueryStateAlpha1(ctx, "", "", nil) - assert.Error(t, err) + require.Error(t, err) _, err = testClient.QueryStateAlpha1(ctx, store, "", nil) - assert.Error(t, err) + require.Error(t, err) _, err = testClient.QueryStateAlpha1(ctx, store, "bad syntax", nil) - assert.Error(t, err) + require.Error(t, err) }) t.Run("query data", func(t *testing.T) { query := `{}` resp, err := testClient.QueryStateAlpha1(ctx, store, query, nil) - assert.NoError(t, err) - assert.Equal(t, 2, len(resp.Results)) + require.NoError(t, err) + assert.Len(t, resp.Results, 2) for _, item := range resp.Results { assert.True(t, item.Key == key1 || item.Key == key2) assert.Equal(t, []byte(data), item.Value) } }) } + +func TestHasRequiredStateArgs(t *testing.T) { + t.Run("empty store should error", func(t *testing.T) { + err := hasRequiredStateArgs("", "key") + require.Error(t, err) + }) + t.Run("empty key should error", func(t *testing.T) { + err := hasRequiredStateArgs("storeName", "") + require.Error(t, err) + }) +} diff --git a/client/wait_test.go b/client/wait_test.go index 6690582b..516e0085 100644 --- a/client/wait_test.go +++ b/client/wait_test.go @@ -21,6 +21,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" @@ -117,23 +119,23 @@ func TestGrpcWaitHappyCase(t *testing.T) { ctx := context.Background() err := testClient.Wait(ctx, waitTimeout) - assert.NoError(t, err) + require.NoError(t, err) } func TestGrpcWaitUnresponsiveTcpServer(t *testing.T) { ctx := context.Background() server, err := createUnresponsiveTCPServer() - assert.NoError(t, err) + require.NoError(t, err) defer server.Close() clientConnectionTimeoutCtx, cancel := context.WithTimeout(ctx, connectionTimeout) defer cancel() client, err := createNonBlockingClient(clientConnectionTimeoutCtx, server.address) - assert.NoError(t, err) + require.NoError(t, err) err = client.Wait(ctx, waitTimeout) - assert.Error(t, err) + require.Error(t, err) assert.Equal(t, errWaitTimedOut, err) assert.GreaterOrEqual(t, atomic.LoadUint64(&server.nClientsSeen), uint64(1)) } @@ -142,16 +144,16 @@ func TestGrpcWaitUnresponsiveUnixServer(t *testing.T) { ctx := context.Background() server, err := createUnresponsiveUnixServer() - assert.NoError(t, err) + require.NoError(t, err) defer server.Close() clientConnectionTimeoutCtx, cancel := context.WithTimeout(ctx, connectionTimeout) defer cancel() client, err := createNonBlockingClient(clientConnectionTimeoutCtx, "unix://"+server.address) - assert.NoError(t, err) + require.NoError(t, err) err = client.Wait(ctx, waitTimeout) - assert.Error(t, err) + require.Error(t, err) assert.Equal(t, errWaitTimedOut, err) assert.GreaterOrEqual(t, atomic.LoadUint64(&server.nClientsSeen), uint64(1)) } diff --git a/go.mod b/go.mod index 2d68451f..79bfe789 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/dapr/go-sdk -go 1.19 +go 1.20 require ( github.com/dapr/dapr v1.12.1-0.20231030205344-441017b888c5 diff --git a/service/grpc/binding.go b/service/grpc/binding.go index a1ae8a84..ae1efecb 100644 --- a/service/grpc/binding.go +++ b/service/grpc/binding.go @@ -54,19 +54,19 @@ func (s *Server) OnBindingEvent(ctx context.Context, in *pb.BindingEventRequest) if in == nil { return nil, errors.New("nil binding event request") } - if fn, ok := s.bindingHandlers[in.Name]; ok { + if fn, ok := s.bindingHandlers[in.GetName()]; ok { e := &common.BindingEvent{ - Data: in.Data, - Metadata: in.Metadata, + Data: in.GetData(), + Metadata: in.GetMetadata(), } data, err := fn(ctx, e) if err != nil { - return nil, fmt.Errorf("error executing %s binding: %w", in.Name, err) + return nil, fmt.Errorf("error executing %s binding: %w", in.GetName(), err) } return &pb.BindingEventResponse{ Data: data, }, nil } - return nil, fmt.Errorf("binding not implemented: %s", in.Name) + return nil, fmt.Errorf("binding not implemented: %s", in.GetName()) } diff --git a/service/grpc/binding_test.go b/service/grpc/binding_test.go index 4756e53e..b87420ec 100644 --- a/service/grpc/binding_test.go +++ b/service/grpc/binding_test.go @@ -18,10 +18,12 @@ import ( "errors" "testing" + "github.com/stretchr/testify/require" + "github.com/golang/protobuf/ptypes/empty" "github.com/stretchr/testify/assert" - runtime "github.com/dapr/dapr/pkg/proto/runtime/v1" + "github.com/dapr/dapr/pkg/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) @@ -35,22 +37,22 @@ func testBindingHandler(ctx context.Context, in *common.BindingEvent) (out []byt func TestListInputBindings(t *testing.T) { server := getTestServer() err := server.AddBindingInvocationHandler("test1", testBindingHandler) - assert.NoError(t, err) + require.NoError(t, err) err = server.AddBindingInvocationHandler("test2", testBindingHandler) - assert.NoError(t, err) + require.NoError(t, err) resp, err := server.ListInputBindings(context.Background(), &empty.Empty{}) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, resp) - assert.Lenf(t, resp.Bindings, 2, "expected 2 handlers") + assert.Lenf(t, resp.GetBindings(), 2, "expected 2 handlers") } func TestBindingForErrors(t *testing.T) { server := getTestServer() err := server.AddBindingInvocationHandler("", nil) - assert.Errorf(t, err, "expected error on nil method name") + require.Errorf(t, err, "expected error on nil method name") err = server.AddBindingInvocationHandler("test", nil) - assert.Errorf(t, err, "expected error on nil method handler") + require.Errorf(t, err, "expected error on nil method handler") } // go test -timeout 30s ./service/grpc -count 1 -run ^TestBinding$ @@ -60,24 +62,24 @@ func TestBinding(t *testing.T) { server := getTestServer() err := server.AddBindingInvocationHandler(methodName, testBindingHandler) - assert.Nil(t, err) + require.NoError(t, err) startTestServer(server) t.Run("binding without event", func(t *testing.T) { _, err := server.OnBindingEvent(ctx, nil) - assert.Error(t, err) + require.Error(t, err) }) t.Run("binding event for wrong method", func(t *testing.T) { in := &runtime.BindingEventRequest{Name: "invalid"} _, err := server.OnBindingEvent(ctx, in) - assert.Error(t, err) + require.Error(t, err) }) t.Run("binding event without data", func(t *testing.T) { in := &runtime.BindingEventRequest{Name: methodName} out, err := server.OnBindingEvent(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) @@ -88,9 +90,9 @@ func TestBinding(t *testing.T) { Data: []byte(data), } out, err := server.OnBindingEvent(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, out) - assert.Equal(t, data, string(out.Data)) + assert.Equal(t, data, string(out.GetData())) }) t.Run("binding event with metadata", func(t *testing.T) { @@ -99,7 +101,7 @@ func TestBinding(t *testing.T) { Metadata: map[string]string{"k1": "v1", "k2": "v2"}, } out, err := server.OnBindingEvent(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, out) }) diff --git a/service/grpc/health_check_test.go b/service/grpc/health_check_test.go index 0a564809..460059a5 100644 --- a/service/grpc/health_check_test.go +++ b/service/grpc/health_check_test.go @@ -18,7 +18,7 @@ import ( "errors" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func testHealthCheckHandler(ctx context.Context) (err error) { @@ -32,7 +32,7 @@ func testHealthCheckHandlerWithError(ctx context.Context) (err error) { func TestHealthCheckHandlerForErrors(t *testing.T) { server := getTestServer() err := server.AddHealthCheckHandler("", nil) - assert.Errorf(t, err, "expected error on nil health check handler") + require.Errorf(t, err, "expected error on nil health check handler") } // go test -timeout 30s ./service/grpc -count 1 -run ^TestHealthCheck$ @@ -44,23 +44,23 @@ func TestHealthCheck(t *testing.T) { t.Run("health check without handler", func(t *testing.T) { _, err := server.HealthCheck(ctx, nil) - assert.Error(t, err) + require.Error(t, err) }) err := server.AddHealthCheckHandler("", testHealthCheckHandler) - assert.Nil(t, err) + require.NoError(t, err) t.Run("health check with handler", func(t *testing.T) { _, err = server.HealthCheck(ctx, nil) - assert.Nil(t, err) + require.NoError(t, err) }) err = server.AddHealthCheckHandler("", testHealthCheckHandlerWithError) - assert.Nil(t, err) + require.NoError(t, err) t.Run("health check with error handler", func(t *testing.T) { _, err = server.HealthCheck(ctx, nil) - assert.Error(t, err) + require.Error(t, err) }) stopTestServer(t, server) diff --git a/service/grpc/invoke.go b/service/grpc/invoke.go index b34c5a58..82dfa1a6 100644 --- a/service/grpc/invoke.go +++ b/service/grpc/invoke.go @@ -58,18 +58,18 @@ func (s *Server) OnInvoke(ctx context.Context, in *cpb.InvokeRequest) (*cpb.Invo return nil, errors.New("authentication failed. app token key not exist") } } - if fn, ok := s.invokeHandlers[in.Method]; ok { + if fn, ok := s.invokeHandlers[in.GetMethod()]; ok { e := &cc.InvocationEvent{} - e.ContentType = in.ContentType + e.ContentType = in.GetContentType() - if in.Data != nil { - e.Data = in.Data.Value - e.DataTypeURL = in.Data.TypeUrl + if in.GetData() != nil { + e.Data = in.GetData().GetValue() + e.DataTypeURL = in.GetData().GetTypeUrl() } - if in.HttpExtension != nil { - e.Verb = in.HttpExtension.Verb.String() - e.QueryString = in.HttpExtension.Querystring + if in.GetHttpExtension() != nil { + e.Verb = in.GetHttpExtension().GetVerb().String() + e.QueryString = in.GetHttpExtension().GetQuerystring() } ct, er := fn(ctx, e) @@ -89,5 +89,5 @@ func (s *Server) OnInvoke(ctx context.Context, in *cpb.InvokeRequest) (*cpb.Invo }, }, nil } - return nil, fmt.Errorf("method not implemented: %s", in.Method) + return nil, fmt.Errorf("method not implemented: %s", in.GetMethod()) } diff --git a/service/grpc/invoke_test.go b/service/grpc/invoke_test.go index 2ef13429..1365172f 100644 --- a/service/grpc/invoke_test.go +++ b/service/grpc/invoke_test.go @@ -19,6 +19,8 @@ import ( "os" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "google.golang.org/grpc/metadata" "google.golang.org/protobuf/types/known/anypb" @@ -45,13 +47,13 @@ func testInvokeHandlerWithError(ctx context.Context, in *cc.InvocationEvent) (ou func TestInvokeErrors(t *testing.T) { server := getTestServer() err := server.AddServiceInvocationHandler("", nil) - assert.Error(t, err) + require.Error(t, err) err = server.AddServiceInvocationHandler("/", nil) - assert.Error(t, err) + require.Error(t, err) err = server.AddServiceInvocationHandler("test", nil) - assert.Error(t, err) + require.Error(t, err) } func TestInvokeWithToken(t *testing.T) { @@ -60,7 +62,7 @@ func TestInvokeWithToken(t *testing.T) { startTestServer(server) methodName := "test" err := server.AddServiceInvocationHandler(methodName, testInvokeHandler) - assert.Nil(t, err) + require.NoError(t, err) t.Run("invoke with token, return success", func(t *testing.T) { grpcMetadata := metadata.New(map[string]string{ cc.APITokenKey: os.Getenv(cc.AppAPITokenEnvVar), @@ -68,12 +70,12 @@ func TestInvokeWithToken(t *testing.T) { ctx := metadata.NewIncomingContext(context.Background(), grpcMetadata) in := &common.InvokeRequest{Method: methodName} _, err := server.OnInvoke(ctx, in) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("invoke with empty token, return failed", func(t *testing.T) { in := &common.InvokeRequest{Method: methodName} _, err := server.OnInvoke(context.Background(), in) - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke with mismatch token, return failed", func(t *testing.T) { grpcMetadata := metadata.New(map[string]string{ @@ -82,7 +84,7 @@ func TestInvokeWithToken(t *testing.T) { ctx := metadata.NewOutgoingContext(context.Background(), grpcMetadata) in := &common.InvokeRequest{Method: methodName} _, err := server.OnInvoke(ctx, in) - assert.Error(t, err) + require.Error(t, err) }) _ = os.Unsetenv(cc.AppAPITokenEnvVar) } @@ -95,28 +97,28 @@ func TestInvoke(t *testing.T) { server := getTestServer() err := server.AddServiceInvocationHandler("/"+methodName, testInvokeHandler) - assert.Nil(t, err) + require.NoError(t, err) err = server.AddServiceInvocationHandler(methodNameWithError, testInvokeHandlerWithError) - assert.Nil(t, err) + require.NoError(t, err) startTestServer(server) t.Run("invoke without request", func(t *testing.T) { _, err := server.OnInvoke(ctx, nil) - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke request with invalid method name", func(t *testing.T) { in := &common.InvokeRequest{Method: "invalid"} _, err := server.OnInvoke(ctx, in) - assert.Error(t, err) + require.Error(t, err) }) t.Run("invoke request without data", func(t *testing.T) { in := &common.InvokeRequest{Method: methodName} _, err := server.OnInvoke(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("invoke request with data", func(t *testing.T) { @@ -126,10 +128,10 @@ func TestInvoke(t *testing.T) { in.Data = &anypb.Any{Value: []byte(data)} in.ContentType = dataContentType out, err := server.OnInvoke(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, out) - assert.Equal(t, dataContentType, out.ContentType) - assert.Equal(t, data, string(out.Data.Value)) + assert.Equal(t, dataContentType, out.GetContentType()) + assert.Equal(t, data, string(out.GetData().GetValue())) }) t.Run("invoke request with error", func(t *testing.T) { @@ -139,7 +141,7 @@ func TestInvoke(t *testing.T) { in.Data = &anypb.Any{Value: []byte(data)} in.ContentType = dataContentType _, err := server.OnInvoke(ctx, in) - assert.Error(t, err) + require.Error(t, err) }) stopTestServer(t, server) diff --git a/service/grpc/service_test.go b/service/grpc/service_test.go index b2a3e97d..877148e3 100644 --- a/service/grpc/service_test.go +++ b/service/grpc/service_test.go @@ -16,6 +16,8 @@ package grpc import ( "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "google.golang.org/grpc" "google.golang.org/grpc/test/bufconn" @@ -40,7 +42,7 @@ func TestServerWithGrpcServer(t *testing.T) { func TestService(t *testing.T) { _, err := NewService("") - assert.Errorf(t, err, "expected error from lack of address") + require.Errorf(t, err, "expected error from lack of address") } func getTestServer() *Server { @@ -60,5 +62,5 @@ func stopTestServer(t *testing.T, server *Server) { assert.NotNil(t, server) err := server.Stop() - assert.Nilf(t, err, "error stopping server") + require.NoErrorf(t, err, "error stopping server") } diff --git a/service/grpc/topic.go b/service/grpc/topic.go index da0c093c..f749de52 100644 --- a/service/grpc/topic.go +++ b/service/grpc/topic.go @@ -76,13 +76,13 @@ func convertRoutes(routes *internal.TopicRoutes) *runtimev1pb.TopicRoutes { // OnTopicEvent fired whenever a message has been published to a topic that has been subscribed. // Dapr sends published messages in a CloudEvents v1.0 envelope. func (s *Server) OnTopicEvent(ctx context.Context, in *runtimev1pb.TopicEventRequest) (*runtimev1pb.TopicEventResponse, error) { - if in == nil || in.Topic == "" || in.PubsubName == "" { + if in == nil || in.GetTopic() == "" || in.GetPubsubName() == "" { // this is really Dapr issue more than the event request format. // since Dapr will not get updated until long after this event expires, just drop it return &runtimev1pb.TopicEventResponse{Status: runtimev1pb.TopicEventResponse_DROP}, errors.New("pub/sub and topic names required") } - key := in.PubsubName + "-" + in.Topic - noValidationKey := in.PubsubName + key := in.GetPubsubName() + "-" + in.GetTopic() + noValidationKey := in.GetPubsubName() var sub *internal.TopicRegistration var ok bool @@ -93,23 +93,23 @@ func (s *Server) OnTopicEvent(ctx context.Context, in *runtimev1pb.TopicEventReq } if ok { - data := interface{}(in.Data) - if len(in.Data) > 0 { - mediaType, _, err := mime.ParseMediaType(in.DataContentType) + data := interface{}(in.GetData()) + if len(in.GetData()) > 0 { + mediaType, _, err := mime.ParseMediaType(in.GetDataContentType()) if err == nil { var v interface{} switch mediaType { case "application/json": - if err := json.Unmarshal(in.Data, &v); err == nil { + if err := json.Unmarshal(in.GetData(), &v); err == nil { data = v } case "text/plain": // Assume UTF-8 encoded string. - data = string(in.Data) + data = string(in.GetData()) default: if strings.HasPrefix(mediaType, "application/") && strings.HasSuffix(mediaType, "+json") { - if err := json.Unmarshal(in.Data, &v); err == nil { + if err := json.Unmarshal(in.GetData(), &v); err == nil { data = v } } @@ -118,26 +118,26 @@ func (s *Server) OnTopicEvent(ctx context.Context, in *runtimev1pb.TopicEventReq } e := &common.TopicEvent{ - ID: in.Id, - Source: in.Source, - Type: in.Type, - SpecVersion: in.SpecVersion, - DataContentType: in.DataContentType, + ID: in.GetId(), + Source: in.GetSource(), + Type: in.GetType(), + SpecVersion: in.GetSpecVersion(), + DataContentType: in.GetDataContentType(), Data: data, - RawData: in.Data, - Topic: in.Topic, - PubsubName: in.PubsubName, + RawData: in.GetData(), + Topic: in.GetTopic(), + PubsubName: in.GetPubsubName(), } h := sub.DefaultHandler - if in.Path != "" { - if pathHandler, ok := sub.RouteHandlers[in.Path]; ok { + if in.GetPath() != "" { + if pathHandler, ok := sub.RouteHandlers[in.GetPath()]; ok { h = pathHandler } } if h == nil { return &runtimev1pb.TopicEventResponse{Status: runtimev1pb.TopicEventResponse_RETRY}, fmt.Errorf( "route %s for pub/sub and topic combination not configured: %s/%s", - in.Path, in.PubsubName, in.Topic, + in.GetPath(), in.GetPubsubName(), in.GetTopic(), ) } retry, err := h(ctx, e) @@ -151,6 +151,6 @@ func (s *Server) OnTopicEvent(ctx context.Context, in *runtimev1pb.TopicEventReq } return &runtimev1pb.TopicEventResponse{Status: runtimev1pb.TopicEventResponse_RETRY}, fmt.Errorf( "pub/sub and topic combination not configured: %s/%s", - in.PubsubName, in.Topic, + in.GetPubsubName(), in.GetTopic(), ) } diff --git a/service/grpc/topic_test.go b/service/grpc/topic_test.go index a716cee9..3c66c6c0 100644 --- a/service/grpc/topic_test.go +++ b/service/grpc/topic_test.go @@ -18,29 +18,31 @@ import ( "errors" "testing" + "github.com/stretchr/testify/require" + "github.com/golang/protobuf/ptypes/empty" "github.com/stretchr/testify/assert" - runtime "github.com/dapr/dapr/pkg/proto/runtime/v1" + "github.com/dapr/dapr/pkg/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) func TestTopicErrors(t *testing.T) { server := getTestServer() err := server.AddTopicEventHandler(nil, nil) - assert.Errorf(t, err, "expected error on nil sub") + require.Errorf(t, err, "expected error on nil sub") sub := &common.Subscription{} err = server.AddTopicEventHandler(sub, nil) - assert.Errorf(t, err, "expected error on invalid sub") + require.Errorf(t, err, "expected error on invalid sub") sub.PubsubName = "messages" err = server.AddTopicEventHandler(sub, nil) - assert.Errorf(t, err, "expected error on sub without topic") + require.Errorf(t, err, "expected error on sub without topic") sub.Topic = "test" err = server.AddTopicEventHandler(sub, nil) - assert.Errorf(t, err, "expected error on sub without handler") + require.Errorf(t, err, "expected error on sub without handler") } func TestTopicSubscriptionList(t *testing.T) { @@ -53,15 +55,15 @@ func TestTopicSubscriptionList(t *testing.T) { Route: "/test", } err := server.AddTopicEventHandler(sub1, eventHandler) - assert.Nil(t, err) + require.NoError(t, err) resp, err := server.ListTopicSubscriptions(context.Background(), &empty.Empty{}) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, resp) - if assert.Lenf(t, resp.Subscriptions, 1, "expected 1 handlers") { - sub := resp.Subscriptions[0] - assert.Equal(t, "messages", sub.PubsubName) - assert.Equal(t, "test", sub.Topic) - assert.Nil(t, sub.Routes) + if assert.Lenf(t, resp.GetSubscriptions(), 1, "expected 1 handlers") { + sub := resp.GetSubscriptions()[0] + assert.Equal(t, "messages", sub.GetPubsubName()) + assert.Equal(t, "test", sub.GetTopic()) + assert.Nil(t, sub.GetRoutes()) } // Add routing rule. @@ -72,20 +74,20 @@ func TestTopicSubscriptionList(t *testing.T) { Match: `event.type == "other"`, } err = server.AddTopicEventHandler(sub2, eventHandler) - assert.Nil(t, err) + require.NoError(t, err) resp, err = server.ListTopicSubscriptions(context.Background(), &empty.Empty{}) - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, resp) - if assert.Lenf(t, resp.Subscriptions, 1, "expected 1 handlers") { - sub := resp.Subscriptions[0] - assert.Equal(t, "messages", sub.PubsubName) - assert.Equal(t, "test", sub.Topic) - if assert.NotNil(t, sub.Routes) { - assert.Equal(t, "/test", sub.Routes.Default) - if assert.Len(t, sub.Routes.Rules, 1) { - rule := sub.Routes.Rules[0] - assert.Equal(t, "/other", rule.Path) - assert.Equal(t, `event.type == "other"`, rule.Match) + if assert.Lenf(t, resp.GetSubscriptions(), 1, "expected 1 handlers") { + sub := resp.GetSubscriptions()[0] + assert.Equal(t, "messages", sub.GetPubsubName()) + assert.Equal(t, "test", sub.GetTopic()) + if assert.NotNil(t, sub.GetRoutes()) { + assert.Equal(t, "/test", sub.GetRoutes().GetDefault()) + if assert.Len(t, sub.GetRoutes().GetRules(), 1) { + rule := sub.GetRoutes().GetRules()[0] + assert.Equal(t, "/other", rule.GetPath()) + assert.Equal(t, `event.type == "other"`, rule.GetMatch()) } } } @@ -102,13 +104,13 @@ func TestTopic(t *testing.T) { server := getTestServer() err := server.AddTopicEventHandler(sub, eventHandler) - assert.Nil(t, err) + require.NoError(t, err) startTestServer(server) t.Run("topic event without request", func(t *testing.T) { _, err := server.OnTopicEvent(ctx, nil) - assert.Error(t, err) + require.Error(t, err) }) t.Run("topic event for wrong topic", func(t *testing.T) { @@ -116,7 +118,7 @@ func TestTopic(t *testing.T) { Topic: "invalid", } _, err := server.OnTopicEvent(ctx, in) - assert.Error(t, err) + require.Error(t, err) }) t.Run("topic event for valid topic", func(t *testing.T) { @@ -131,7 +133,7 @@ func TestTopic(t *testing.T) { PubsubName: sub.PubsubName, } _, err := server.OnTopicEvent(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) }) stopTestServer(t, server) @@ -148,7 +150,7 @@ func TestTopicWithValidationDisabled(t *testing.T) { server := getTestServer() err := server.AddTopicEventHandler(sub, eventHandler) - assert.Nil(t, err) + require.NoError(t, err) startTestServer(server) @@ -164,7 +166,7 @@ func TestTopicWithValidationDisabled(t *testing.T) { } _, err = server.OnTopicEvent(ctx, in) - assert.NoError(t, err) + require.NoError(t, err) } func TestTopicWithErrors(t *testing.T) { @@ -182,10 +184,10 @@ func TestTopicWithErrors(t *testing.T) { server := getTestServer() err := server.AddTopicEventHandler(sub1, eventHandlerWithRetryError) - assert.Nil(t, err) + require.NoError(t, err) err = server.AddTopicEventHandler(sub2, eventHandlerWithError) - assert.Nil(t, err) + require.NoError(t, err) startTestServer(server) @@ -201,8 +203,8 @@ func TestTopicWithErrors(t *testing.T) { PubsubName: sub1.PubsubName, } resp, err := server.OnTopicEvent(ctx, in) - assert.Error(t, err) - assert.Equal(t, resp.GetStatus(), runtime.TopicEventResponse_RETRY) + require.Error(t, err) + assert.Equal(t, runtime.TopicEventResponse_RETRY, resp.GetStatus()) }) t.Run("topic event for error", func(t *testing.T) { @@ -217,8 +219,8 @@ func TestTopicWithErrors(t *testing.T) { PubsubName: sub2.PubsubName, } resp, err := server.OnTopicEvent(ctx, in) - assert.NoError(t, err) - assert.Equal(t, resp.GetStatus(), runtime.TopicEventResponse_DROP) + require.NoError(t, err) + assert.Equal(t, runtime.TopicEventResponse_DROP, resp.GetStatus()) }) stopTestServer(t, server) @@ -291,7 +293,7 @@ func TestEventDataHandling(t *testing.T) { return false, nil } err := s.AddTopicEventHandler(sub, handler) - assert.NoErrorf(t, err, "error adding event handler") + require.NoErrorf(t, err, "error adding event handler") startTestServer(s) diff --git a/service/http/binding_test.go b/service/http/binding_test.go index 59da9ed4..0f390163 100644 --- a/service/http/binding_test.go +++ b/service/http/binding_test.go @@ -21,6 +21,8 @@ import ( "strings" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "github.com/dapr/go-sdk/service/common" @@ -29,7 +31,7 @@ import ( func TestBindingHandlerWithoutHandler(t *testing.T) { s := newServer("", nil) err := s.AddBindingInvocationHandler("/", nil) - assert.Errorf(t, err, "expected error adding nil binding event handler") + require.Errorf(t, err, "expected error adding nil binding event handler") } func TestBindingHandlerWithoutData(t *testing.T) { @@ -43,10 +45,10 @@ func TestBindingHandlerWithoutData(t *testing.T) { } return nil, nil }) - assert.NoErrorf(t, err, "error adding binding event handler") + require.NoErrorf(t, err, "error adding binding event handler") req, err := http.NewRequest(http.MethodPost, "/", nil) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -64,10 +66,10 @@ func TestBindingHandlerWithData(t *testing.T) { } return []byte("test"), nil }) - assert.NoErrorf(t, err, "error adding binding event handler") + require.NoErrorf(t, err, "error adding binding event handler") req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(data)) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -91,13 +93,13 @@ func TestBindingHandlerErrors(t *testing.T) { data := `{"name": "test"}` s := newServer("", nil) err := s.AddBindingInvocationHandler("", bindingHandlerFn) - assert.Errorf(t, err, "expected error adding binding event handler sans route") + require.Errorf(t, err, "expected error adding binding event handler sans route") err = s.AddBindingInvocationHandler("errors", bindingHandlerFnWithError) - assert.NoErrorf(t, err, "error adding binding event handler sans slash") + require.NoErrorf(t, err, "error adding binding event handler sans slash") req, err := http.NewRequest(http.MethodPost, "/errors", strings.NewReader(data)) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() diff --git a/service/http/health_check_test.go b/service/http/health_check_test.go index 01a935d8..8327d2b0 100644 --- a/service/http/health_check_test.go +++ b/service/http/health_check_test.go @@ -21,13 +21,15 @@ import ( "net/http/httptest" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) func TestHealthCheckHandlerWithoutHandler(t *testing.T) { s := newServer("", nil) err := s.AddHealthCheckHandler("/", nil) - assert.Errorf(t, err, "expected error adding nil health check handler") + require.Errorf(t, err, "expected error adding nil health check handler") } func TestHealthCheckHandler(t *testing.T) { @@ -37,10 +39,10 @@ func TestHealthCheckHandler(t *testing.T) { return nil }) - assert.NoError(t, err) + require.NoError(t, err) req, err := http.NewRequest(http.MethodGet, "/", nil) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -55,10 +57,10 @@ func TestHealthCheckHandler(t *testing.T) { return errors.New("app is unhealthy") }) - assert.NoError(t, err) + require.NoError(t, err) req, err := http.NewRequest(http.MethodGet, "/", nil) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() diff --git a/service/http/invoke_test.go b/service/http/invoke_test.go index 30db792e..e1b5bfaa 100644 --- a/service/http/invoke_test.go +++ b/service/http/invoke_test.go @@ -24,6 +24,8 @@ import ( "strings" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "google.golang.org/grpc/metadata" @@ -33,10 +35,10 @@ import ( func TestInvocationHandlerWithoutHandler(t *testing.T) { s := newServer("", nil) err := s.AddServiceInvocationHandler("/hello", nil) - assert.Errorf(t, err, "expected error adding event handler") + require.Errorf(t, err, "expected error adding event handler") err = s.AddServiceInvocationHandler("/", nil) - assert.Errorf(t, err, "expected error adding event handler, invalid router") + require.Errorf(t, err, "expected error adding event handler, invalid router") } func TestInvocationHandlerWithToken(t *testing.T) { @@ -55,11 +57,11 @@ func TestInvocationHandlerWithToken(t *testing.T) { } return }) - assert.NoErrorf(t, err, "adding event handler success") + require.NoErrorf(t, err, "adding event handler success") // forbbiden. req, err := http.NewRequest(http.MethodPost, "/hello", strings.NewReader(data)) - assert.NoErrorf(t, err, "creating request success") + require.NoErrorf(t, err, "creating request success") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -89,10 +91,10 @@ func TestInvocationHandlerWithData(t *testing.T) { } return }) - assert.NoErrorf(t, err, "adding event handler success") + require.NoErrorf(t, err, "adding event handler success") req, err := http.NewRequest(http.MethodPost, "/hello", strings.NewReader(data)) - assert.NoErrorf(t, err, "creating request success") + require.NoErrorf(t, err, "creating request success") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -100,7 +102,7 @@ func TestInvocationHandlerWithData(t *testing.T) { assert.Equal(t, http.StatusOK, resp.Code) b, err := io.ReadAll(resp.Body) - assert.NoErrorf(t, err, "reading response body success") + require.NoErrorf(t, err, "reading response body success") assert.Equal(t, data, string(b)) } @@ -113,10 +115,10 @@ func TestInvocationHandlerWithoutInputData(t *testing.T) { } return &common.Content{}, nil }) - assert.NoErrorf(t, err, "adding event handler success") + require.NoErrorf(t, err, "adding event handler success") req, err := http.NewRequest(http.MethodPost, "/hello", nil) - assert.NoErrorf(t, err, "creating request success") + require.NoErrorf(t, err, "creating request success") req.Header.Set("Content-Type", "application/json") resp := httptest.NewRecorder() @@ -124,7 +126,7 @@ func TestInvocationHandlerWithoutInputData(t *testing.T) { assert.Equal(t, http.StatusOK, resp.Code) b, err := io.ReadAll(resp.Body) - assert.NoErrorf(t, err, "reading response body success") + require.NoErrorf(t, err, "reading response body success") assert.NotNil(t, b) assert.Equal(t, "", string(b)) } @@ -137,13 +139,13 @@ func TestInvocationHandlerWithInvalidRoute(t *testing.T) { s := newServer("", nil) err := s.AddServiceInvocationHandler("no-slash", emptyInvocationFn) - assert.NoErrorf(t, err, "adding no slash route event handler success") + require.NoErrorf(t, err, "adding no slash route event handler success") err = s.AddServiceInvocationHandler("", emptyInvocationFn) - assert.Errorf(t, err, "expected error from adding no route event handler") + require.Errorf(t, err, "expected error from adding no route event handler") err = s.AddServiceInvocationHandler("/a", emptyInvocationFn) - assert.NoErrorf(t, err, "adding event handler success") + require.NoErrorf(t, err, "adding event handler success") makeEventRequest(t, s, "/b", "", http.StatusNotFound) } @@ -156,7 +158,7 @@ func TestInvocationHandlerWithError(t *testing.T) { s := newServer("", nil) err := s.AddServiceInvocationHandler("/error", errorInvocationFn) - assert.NoErrorf(t, err, "adding error event handler success") + require.NoErrorf(t, err, "adding error event handler success") makeEventRequest(t, s, "/error", "", http.StatusInternalServerError) } @@ -195,11 +197,11 @@ func TestInvocationHandlerWithCustomizedHeader(t *testing.T) { return }) - assert.NoErrorf(t, err, "adding event handler success") + require.NoErrorf(t, err, "adding event handler success") customizedHeader := "Customized-Header" req, err := http.NewRequest(http.MethodPost, "/hello", strings.NewReader(data)) - assert.NoErrorf(t, err, "creating request success") + require.NoErrorf(t, err, "creating request success") req.Header.Set("Content-Type", "application/json") req.Header.Set(customizedHeader, "Value") @@ -208,11 +210,11 @@ func TestInvocationHandlerWithCustomizedHeader(t *testing.T) { assert.Equal(t, http.StatusOK, resp.Code) b, err := io.ReadAll(resp.Body) - assert.NoErrorf(t, err, "reading response body success") + require.NoErrorf(t, err, "reading response body success") d2 := map[string]interface{}{} err = json.Unmarshal(b, &d2) - assert.Nil(t, err) + require.NoError(t, err) assert.Contains(t, d2, customizedHeader) - assert.Equal(t, d2[customizedHeader], "Value") + assert.Equal(t, "Value", d2[customizedHeader]) } diff --git a/service/http/service_test.go b/service/http/service_test.go index 34da670a..010f7790 100644 --- a/service/http/service_test.go +++ b/service/http/service_test.go @@ -21,6 +21,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" ) @@ -28,7 +30,7 @@ func TestStoppingUnstartedService(t *testing.T) { s := newServer("", nil) assert.NotNil(t, s) err := s.Stop() - assert.NoError(t, err) + require.NoError(t, err) } func TestStoppingStartedService(t *testing.T) { @@ -42,23 +44,23 @@ func TestStoppingStartedService(t *testing.T) { }() // Wait for the server to start time.Sleep(200 * time.Millisecond) - assert.NoError(t, s.Stop()) + require.NoError(t, s.Stop()) } func TestStartingStoppedService(t *testing.T) { s := newServer(":3333", nil) assert.NotNil(t, s) stopErr := s.Stop() - assert.NoError(t, stopErr) + require.NoError(t, stopErr) startErr := s.Start() - assert.Error(t, startErr, "expected starting a stopped server to raise an error") + require.Error(t, startErr, "expected starting a stopped server to raise an error") assert.Equal(t, startErr.Error(), http.ErrServerClosed.Error()) } func TestSettingOptions(t *testing.T) { req, err := http.NewRequest(http.MethodOptions, "/", nil) - assert.NoErrorf(t, err, "error creating request") + require.NoErrorf(t, err, "error creating request") w := httptest.NewRecorder() setOptions(w, req) resp := w.Result() @@ -89,7 +91,7 @@ func testRequestWithResponseBody(t *testing.T, s *Server, r *http.Request, expec rez := rr.Result() defer rez.Body.Close() rspBody, err := io.ReadAll(rez.Body) - assert.Nil(t, err) + require.NoError(t, err) assert.NotNil(t, rez) assert.Equal(t, expectedStatusCode, rez.StatusCode) assert.Equal(t, expectedBody, rspBody) diff --git a/service/http/topic_test.go b/service/http/topic_test.go index 2d236383..6fa30a3c 100644 --- a/service/http/topic_test.go +++ b/service/http/topic_test.go @@ -57,7 +57,7 @@ func TestEventNilHandler(t *testing.T) { Metadata: map[string]string{}, } err := s.AddTopicEventHandler(sub, nil) - assert.Errorf(t, err, "expected error adding event handler") + require.Errorf(t, err, "expected error adding event handler") } func TestEventHandler(t *testing.T) { @@ -83,7 +83,7 @@ func TestEventHandler(t *testing.T) { Metadata: map[string]string{}, } err := s.AddTopicEventHandler(sub, testTopicFunc) - assert.NoErrorf(t, err, "error adding event handler") + require.NoErrorf(t, err, "error adding event handler") sub2 := &common.Subscription{ PubsubName: "messages", @@ -92,7 +92,7 @@ func TestEventHandler(t *testing.T) { Metadata: map[string]string{}, } err = s.AddTopicEventHandler(sub2, testErrorTopicFunc) - assert.NoErrorf(t, err, "error adding error event handler") + require.NoErrorf(t, err, "error adding error event handler") sub3 := &common.Subscription{ PubsubName: "messages", @@ -102,7 +102,7 @@ func TestEventHandler(t *testing.T) { Priority: 1, } err = s.AddTopicEventHandler(sub3, testTopicFunc) - assert.NoErrorf(t, err, "error adding error event handler") + require.NoErrorf(t, err, "error adding error event handler") s.registerBaseHandler() @@ -256,7 +256,7 @@ func TestEventDataHandling(t *testing.T) { return false, nil } err := s.AddTopicEventHandler(sub, handler) - assert.NoErrorf(t, err, "error adding event handler") + require.NoErrorf(t, err, "error adding event handler") s.registerBaseHandler() @@ -336,7 +336,7 @@ func makeRequest(t *testing.T, s *Server, route, data, method string, expectedSt t.Helper() req, err := http.NewRequest(method, route, strings.NewReader(data)) - assert.NoErrorf(t, err, "error creating request: %s", data) + require.NoErrorf(t, err, "error creating request: %s", data) testRequest(t, s, req, expectedStatusCode) } @@ -344,7 +344,7 @@ func makeRequestWithExpectedBody(t *testing.T, s *Server, route, data, method st t.Helper() req, err := http.NewRequest(method, route, strings.NewReader(data)) - assert.NoErrorf(t, err, "error creating request: %s", data) + require.NoErrorf(t, err, "error creating request: %s", data) testRequestWithResponseBody(t, s, req, expectedStatusCode, expectedBody) } @@ -352,7 +352,7 @@ func makeEventRequest(t *testing.T, s *Server, route, data string, expectedStatu t.Helper() req, err := http.NewRequest(http.MethodPost, route, strings.NewReader(data)) - assert.NoErrorf(t, err, "error creating request: %s", data) + require.NoErrorf(t, err, "error creating request: %s", data) req.Header.Set("Content-Type", "application/json") testRequest(t, s, req, expectedStatusCode) } @@ -360,19 +360,19 @@ func makeEventRequest(t *testing.T, s *Server, route, data string, expectedStatu func TestAddingInvalidEventHandlers(t *testing.T) { s := newServer("", nil) err := s.AddTopicEventHandler(nil, testTopicFunc) - assert.Errorf(t, err, "expected error adding no sub event handler") + require.Errorf(t, err, "expected error adding no sub event handler") sub := &common.Subscription{Metadata: map[string]string{}} err = s.AddTopicEventHandler(sub, testTopicFunc) - assert.Errorf(t, err, "expected error adding empty sub event handler") + require.Errorf(t, err, "expected error adding empty sub event handler") sub.Topic = "test" err = s.AddTopicEventHandler(sub, testTopicFunc) - assert.Errorf(t, err, "expected error adding sub without component event handler") + require.Errorf(t, err, "expected error adding sub without component event handler") sub.PubsubName = "messages" err = s.AddTopicEventHandler(sub, testTopicFunc) - assert.Errorf(t, err, "expected error adding sub without route event handler") + require.Errorf(t, err, "expected error adding sub without route event handler") } func TestRawPayloadDecode(t *testing.T) { @@ -384,7 +384,7 @@ func TestRawPayloadDecode(t *testing.T) { err = errors.New("error decode data_base64") } if err != nil { - assert.NoErrorf(t, err, "error rawPayload decode") + require.NoErrorf(t, err, "error rawPayload decode") } return } @@ -405,7 +405,7 @@ func TestRawPayloadDecode(t *testing.T) { }, } err := s.AddTopicEventHandler(sub3, testRawTopicFunc) - assert.NoErrorf(t, err, "error adding raw event handler") + require.NoErrorf(t, err, "error adding raw event handler") s.registerBaseHandler() makeEventRequest(t, s, "/raw", rawData, http.StatusOK) diff --git a/service/internal/topicregistrar_test.go b/service/internal/topicregistrar_test.go index 05a55458..64be563c 100644 --- a/service/internal/topicregistrar_test.go +++ b/service/internal/topicregistrar_test.go @@ -4,6 +4,8 @@ import ( "context" "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "github.com/dapr/go-sdk/service/common" @@ -65,9 +67,9 @@ func TestTopicRegistrarValidation(t *testing.T) { t.Run(name, func(t *testing.T) { m := internal.TopicRegistrar{} if tt.err != "" { - assert.EqualError(t, m.AddSubscription(&tt.sub, tests[name].fn), tt.err) + require.EqualError(t, m.AddSubscription(&tt.sub, tests[name].fn), tt.err) } else { - assert.NoError(t, m.AddSubscription(&tt.sub, tt.fn)) + require.NoError(t, m.AddSubscription(&tt.sub, tt.fn)) } }) } @@ -84,7 +86,7 @@ func TestTopicAddSubscriptionMetadata(t *testing.T) { Metadata: map[string]string{"key": "value"}, } - assert.NoError(t, topicRegistrar.AddSubscription(sub, handler)) + require.NoError(t, topicRegistrar.AddSubscription(sub, handler)) actual := topicRegistrar["pubsubname-topic"].Subscription expected := &internal.TopicSubscription{ diff --git a/service/internal/topicsubscription_test.go b/service/internal/topicsubscription_test.go index 7e30366c..3762b36a 100644 --- a/service/internal/topicsubscription_test.go +++ b/service/internal/topicsubscription_test.go @@ -3,6 +3,8 @@ package internal_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/assert" "github.com/dapr/go-sdk/service/internal" @@ -11,54 +13,54 @@ import ( func TestTopicSubscripiton(t *testing.T) { t.Run("duplicate metadata", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.SetMetadata(map[string]string{ + require.NoError(t, sub.SetMetadata(map[string]string{ "test": "test", })) - assert.EqualError(t, sub.SetMetadata(map[string]string{ + require.EqualError(t, sub.SetMetadata(map[string]string{ "test": "test", }), "subscription for topic mytopic on pubsub test already has metadata set") }) t.Run("duplicate route", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.SetDefaultRoute("/test")) + require.NoError(t, sub.SetDefaultRoute("/test")) assert.Equal(t, "/test", sub.Route) - assert.EqualError(t, sub.SetDefaultRoute("/test"), + require.EqualError(t, sub.SetDefaultRoute("/test"), "subscription for topic mytopic on pubsub test already has route /test") }) t.Run("duplicate route after routing rule", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.AddRoutingRule("/other", `event.type == "test"`, 0)) - assert.NoError(t, sub.SetDefaultRoute("/test")) - assert.EqualError(t, sub.SetDefaultRoute("/test"), + require.NoError(t, sub.AddRoutingRule("/other", `event.type == "test"`, 0)) + require.NoError(t, sub.SetDefaultRoute("/test")) + require.EqualError(t, sub.SetDefaultRoute("/test"), "subscription for topic mytopic on pubsub test already has route /test") }) t.Run("default route after routing rule", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.SetDefaultRoute("/test")) + require.NoError(t, sub.SetDefaultRoute("/test")) assert.Equal(t, "/test", sub.Route) - assert.NoError(t, sub.AddRoutingRule("/other", `event.type == "test"`, 0)) + require.NoError(t, sub.AddRoutingRule("/other", `event.type == "test"`, 0)) assert.Equal(t, "", sub.Route) assert.Equal(t, "/test", sub.Routes.Default) - assert.EqualError(t, sub.SetDefaultRoute("/test"), + require.EqualError(t, sub.SetDefaultRoute("/test"), "subscription for topic mytopic on pubsub test already has route /test") }) t.Run("duplicate routing rule priority", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.AddRoutingRule("/other", `event.type == "other"`, 1)) - assert.EqualError(t, sub.AddRoutingRule("/test", `event.type == "test"`, 1), + require.NoError(t, sub.AddRoutingRule("/other", `event.type == "other"`, 1)) + require.EqualError(t, sub.AddRoutingRule("/test", `event.type == "test"`, 1), "subscription for topic mytopic on pubsub test already has a routing rule with priority 1") }) t.Run("priority ordering", func(t *testing.T) { sub := internal.NewTopicSubscription("test", "mytopic") - assert.NoError(t, sub.AddRoutingRule("/100", `event.type == "100"`, 100)) - assert.NoError(t, sub.AddRoutingRule("/1", `event.type == "1"`, 1)) - assert.NoError(t, sub.AddRoutingRule("/50", `event.type == "50"`, 50)) - assert.NoError(t, sub.SetDefaultRoute("/default")) + require.NoError(t, sub.AddRoutingRule("/100", `event.type == "100"`, 100)) + require.NoError(t, sub.AddRoutingRule("/1", `event.type == "1"`, 1)) + require.NoError(t, sub.AddRoutingRule("/50", `event.type == "50"`, 50)) + require.NoError(t, sub.SetDefaultRoute("/default")) assert.Equal(t, "/default", sub.Routes.Default) if assert.Len(t, sub.Routes.Rules, 3) { assert.Equal(t, "/1", sub.Routes.Rules[0].Path) diff --git a/tools/check-lint-version/go.mod b/tools/check-lint-version/go.mod index 43d97119..504d393e 100644 --- a/tools/check-lint-version/go.mod +++ b/tools/check-lint-version/go.mod @@ -1,6 +1,6 @@ module github.com/dapr/go-sdk/tools/check-lint-version -go 1.19 +go 1.20 require ( github.com/stretchr/testify v1.8.4 diff --git a/tools/check-lint-version/main_test.go b/tools/check-lint-version/main_test.go index e7c842d9..043ba5d0 100644 --- a/tools/check-lint-version/main_test.go +++ b/tools/check-lint-version/main_test.go @@ -4,39 +4,40 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestParseWorkflow(t *testing.T) { t.Run("parse invalid workflow file", func(t *testing.T) { parsedVersion, err := parseWorkflowVersionFromFile("../../.github/workflows/invalid.yaml") assert.Equal(t, "", parsedVersion) - assert.Error(t, err) + require.Error(t, err) }) t.Run("parse workflow file with a missing key", func(t *testing.T) { parsedVersion, err := parseWorkflowVersionFromFile("./testing/invalid-test.yml") assert.Equal(t, "", parsedVersion) - assert.NoError(t, err) + require.NoError(t, err) }) t.Run("parse an invalid workflow file", func(t *testing.T) { parsedVersion, err := parseWorkflowVersionFromFile("./testing/invalid-yaml.yml") assert.Equal(t, "", parsedVersion) - assert.Error(t, err) + require.Error(t, err) }) t.Run("parse testing workflow file", func(t *testing.T) { parsedVersion, err := parseWorkflowVersionFromFile("../../.github/workflows/test-tooling.yml") - assert.Equal(t, "v1.54.2", parsedVersion) - assert.NoError(t, err) + assert.Equal(t, "v1.55.2", parsedVersion) + require.NoError(t, err) }) } func TestGetCurrentVersion(t *testing.T) { t.Run("get current version from system", func(t *testing.T) { currentVersion, err := getCurrentVersion() - assert.Equal(t, "v1.54.2", currentVersion) - assert.NoError(t, err) + assert.Equal(t, "v1.55.2", currentVersion) + require.NoError(t, err) }) // TODO: test failure to detect current version @@ -48,23 +49,23 @@ func TestGetCurrentVersion(t *testing.T) { func TestIsVersionValid(t *testing.T) { t.Run("compare versions - exactly equal to", func(t *testing.T) { - assert.Equal(t, true, isVersionValid("v1.54.2", "v1.54.2")) + assert.True(t, true, isVersionValid("v1.54.2", "v1.54.2")) }) t.Run("compare versions - patch version greater (workflow)", func(t *testing.T) { - assert.Equal(t, true, isVersionValid("v1.54.3", "v1.54.2")) + assert.True(t, true, isVersionValid("v1.54.3", "v1.54.2")) }) t.Run("compare versions - patch version greater (installed)", func(t *testing.T) { - assert.Equal(t, true, isVersionValid("v1.54.2", "v1.54.3")) + assert.True(t, true, isVersionValid("v1.54.2", "v1.54.3")) }) t.Run("compare versions - invalid (installed)", func(t *testing.T) { - assert.Equal(t, false, isVersionValid("v1.54.2", "v1.52.2")) + assert.False(t, false, isVersionValid("v1.54.2", "v1.52.2")) }) t.Run("compare versions - invalid (workflow)", func(t *testing.T) { - assert.Equal(t, false, isVersionValid("v1.52.2", "v1.54.2")) + assert.False(t, false, isVersionValid("v1.52.2", "v1.54.2")) }) }