dapr
/
go-sdk
mirror of https://github.com/dapr/go-sdk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: go1.20 and golangci-lint v1.55.2 (#480) 

* fix: remove invalid 'unused' config and fix wsl trailing whitespace key name

Signed-off-by: mikeee <hey@mike.ee>

* fix: disable inamedparam linter

Signed-off-by: mikeee <hey@mike.ee>

* fix: update package and tool to go1.21.5

Signed-off-by: mikeee <hey@mike.ee>

* fix: correct majority of the testifylinter issues relating to error assertions

Signed-off-by: mikeee <hey@mike.ee>

* fix: reverse actual and expected values

Signed-off-by: mikeee <hey@mike.ee>

* fix: correct test cases

Signed-off-by: mikeee <hey@mike.ee>

* fix: correct misspell - upsert

Signed-off-by: mikeee <hey@mike.ee>

* fix: add missing import

Signed-off-by: mikeee <hey@mike.ee>

* update: bump validation workflow to 1.21

Signed-off-by: mikeee <hey@mike.ee>

* fix: refactor direct access references to proto fields

Signed-off-by: mikeee <hey@mike.ee>

* fix: revert to go1.20 retaining version-1 support

Signed-off-by: mikeee <hey@mike.ee>

* fix: update test-dapr-bot workflow golangci-lint ver to 1.55.2

Signed-off-by: mikeee <hey@mike.ee>

* fix: fix assertions for dapr-bot and check-lint-version

Signed-off-by: mikeee <hey@mike.ee>

* fix: remove length function call

Signed-off-by: mikeee <hey@mike.ee>

* fix: fix StateConsistency logic and add tests to satisfy codecov

Signed-off-by: mikeee <hey@mike.ee>

* tests: add coverage of empty store names for delete bulk state item method

Signed-off-by: mikeee <hey@mike.ee>

---------

Signed-off-by: mikeee <hey@mike.ee>
This commit is contained in:
mikeee 2023-12-11 02:51:26 +00:00 committed by GitHub
parent 959de75422
commit 04f7b595b6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
53 changed files with 624 additions and 524 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/dapr-bot.yml vendored
View File

@ -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/

2
.github/workflows/dapr-bot/Makefile vendored
View File

@ -1,4 +1,4 @@
GO_COMPAT_VERSION=1.21
GO_COMPAT_VERSION=1.20
.PHONY: cover
cover:

27
.github/workflows/dapr-bot/bot_test.go vendored
View File

@ -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)
})
}

13
.github/workflows/dapr-bot/event_test.go vendored
View File

@ -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])
})
}

2
.github/workflows/dapr-bot/go.mod vendored
View File

@ -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

1
.github/workflows/dapr-bot/go.sum vendored
View File

@ -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=

2
.github/workflows/release-on-tag.yaml vendored
View File

@ -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

4
.github/workflows/test-dapr-bot.yml vendored
View File

@ -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

3
.github/workflows/test-on-push.yaml vendored
View File

@ -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

4
.github/workflows/test-tooling.yml vendored
View File

@ -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

9
.golangci.yml
View File

@ -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

2
Makefile
View File

@ -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

2
actor/manager/container_test.go
View File

@ -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))
}

4
client/actor.go
View File

@ -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 {

72
client/actor_test.go
View File

@ -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))
})
}

4
client/binding.go
View File

@ -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
}

10
client/binding_test.go
View File

@ -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))
})

64
client/client_test.go
View File

@ -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
}

22
client/configuration.go
View File

@ -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

14
client/configuration_test.go
View File

@ -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))

6
client/crypto.go
View File

@ -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

6
client/crypto_test.go
View File

@ -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

2
client/invoke.go
View File

@ -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
}

32
client/invoke_test.go
View File

@ -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())
})
}

6
client/lock.go
View File

@ -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
}

14
client/lock_test.go
View File

@ -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)
})
}

54
client/metadata.go
View File

@ -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(),

8
client/metadata_test.go
View File

@ -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"])
})
}

18
client/pubsub.go
View File

@ -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

76
client/pubsub_test.go
View File

@ -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)
})
}
})

4
client/secret.go
View File

@ -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
}
}

16
client/secret_test.go
View File

@ -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)
})
}

42
client/state.go
View File

@ -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,
Results: make([]QueryItem, len(resp.GetResults())),
Token: resp.GetToken(),
Metadata: resp.GetMetadata(),
}
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
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

172
client/state_test.go
View File

@ -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)
})
}

16
client/wait_test.go
View File

@ -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))
}

2
go.mod
View File

@ -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

10
service/grpc/binding.go
View File

@ -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())
}

30
service/grpc/binding_test.go
View File

@ -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)
})

14
service/grpc/health_check_test.go
View File

@ -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)

18
service/grpc/invoke.go
View File

@ -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())
}

34
service/grpc/invoke_test.go
View File

@ -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)

6
service/grpc/service_test.go
View File

@ -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")
}

42
service/grpc/topic.go
View File

@ -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(),
)
}

76
service/grpc/topic_test.go
View File

@ -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)

18
service/http/binding_test.go
View File

@ -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()

12
service/http/health_check_test.go
View File

@ -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()

40
service/http/invoke_test.go
View File

@ -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])
}

14
service/http/service_test.go
View File

@ -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)

28
service/http/topic_test.go
View File

@ -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)

8
service/internal/topicregistrar_test.go
View File

@ -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{

34
service/internal/topicsubscription_test.go
View File

@ -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)

2
tools/check-lint-version/go.mod
View File

@ -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

25
tools/check-lint-version/main_test.go
View File

@ -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"))
})
}