本文整理汇总了Golang中github.com/golang/mock/gomock.Eq函数的典型用法代码示例。如果您正苦于以下问题:Golang Eq函数的具体用法?Golang Eq怎么用?Golang Eq使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Eq函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestMatchers
func TestMatchers(t *testing.T) {
type e interface{}
type testCase struct {
matcher gomock.Matcher
yes, no []e
}
tests := []testCase{
testCase{gomock.Any(), []e{3, nil, "foo"}, nil},
testCase{gomock.Eq(4), []e{4}, []e{3, "blah", nil, int64(4)}},
testCase{gomock.Nil(),
[]e{nil, (error)(nil), (chan bool)(nil), (*int)(nil)},
[]e{"", 0, make(chan bool), errors.New("err"), new(int)}},
testCase{gomock.Not(gomock.Eq(4)), []e{3, "blah", nil, int64(4)}, []e{4}},
}
for i, test := range tests {
for _, x := range test.yes {
if !test.matcher.Matches(x) {
t.Errorf(`test %d: "%v %s" should be true.`, i, x, test.matcher)
}
}
for _, x := range test.no {
if test.matcher.Matches(x) {
t.Errorf(`test %d: "%v %s" should be false.`, i, x, test.matcher)
}
}
}
}
示例2: TestConnector_PostSubscriptionNoMocks
func TestConnector_PostSubscriptionNoMocks(t *testing.T) {
_, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
recorder := httptest.NewRecorder()
conn, mocks := getTestConnector(t, Config{
Name: "test",
Schema: "test",
Prefix: "/connector/",
URLPattern: "/{device_token}/{user_id}/{topic:.*}",
}, false, false)
entriesC := make(chan [2]string)
mocks.kvstore.EXPECT().Iterate(gomock.Eq("test"), gomock.Eq("")).Return(entriesC)
close(entriesC)
mocks.kvstore.EXPECT().Put(gomock.Eq("test"), gomock.Eq(GenerateKey("/topic1", map[string]string{
"device_token": "device1",
"user_id": "user1",
})), gomock.Any())
mocks.router.EXPECT().Subscribe(gomock.Any())
err := conn.Start()
a.NoError(err)
defer conn.Stop()
req, err := http.NewRequest(http.MethodPost, "/connector/device1/user1/topic1", strings.NewReader(""))
a.NoError(err)
conn.ServeHTTP(recorder, req)
a.Equal(`{"subscribed":"/topic1"}`, recorder.Body.String())
time.Sleep(100 * time.Millisecond)
}
示例3: TestRemember
func TestRemember(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockIndex := mock_user.NewMockIndex(ctrl)
mockIndex.EXPECT().Put("a", 1) // literals work
mockIndex.EXPECT().Put("b", gomock.Eq(2)) // matchers work too
// NillableRet returns error. Not declaring it should result in a nil return.
mockIndex.EXPECT().NillableRet()
// Calls that returns something assignable to the return type.
boolc := make(chan bool)
// In this case, "chan bool" is assignable to "chan<- bool".
mockIndex.EXPECT().ConcreteRet().Return(boolc)
// In this case, nil is assignable to "chan<- bool".
mockIndex.EXPECT().ConcreteRet().Return(nil)
// Should be able to place expectations on variadic methods.
mockIndex.EXPECT().Ellip("%d", 0, 1, 1, 2, 3) // direct args
tri := []interface{}{1, 3, 6, 10, 15}
mockIndex.EXPECT().Ellip("%d", tri...) // args from slice
mockIndex.EXPECT().EllipOnly(gomock.Eq("arg"))
user.Remember(mockIndex, []string{"a", "b"}, []interface{}{1, 2})
// Check the ConcreteRet calls.
if c := mockIndex.ConcreteRet(); c != boolc {
t.Errorf("ConcreteRet: got %v, want %v", c, boolc)
}
if c := mockIndex.ConcreteRet(); c != nil {
t.Errorf("ConcreteRet: got %v, want nil", c)
}
// Try one with an action.
calledString := ""
mockIndex.EXPECT().Put(gomock.Any(), gomock.Any()).Do(func(key string, _ interface{}) {
calledString = key
})
mockIndex.EXPECT().NillableRet()
user.Remember(mockIndex, []string{"blah"}, []interface{}{7})
if calledString != "blah" {
t.Fatalf(`Uh oh. %q != "blah"`, calledString)
}
// Use Do with a nil arg.
mockIndex.EXPECT().Put("nil-key", gomock.Any()).Do(func(key string, value interface{}) {
if value != nil {
t.Errorf("Put did not pass through nil; got %v", value)
}
})
mockIndex.EXPECT().NillableRet()
user.Remember(mockIndex, []string{"nil-key"}, []interface{}{nil})
}
示例4: TestConnector_GetListWithFilters
func TestConnector_GetListWithFilters(t *testing.T) {
_, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
recorder := httptest.NewRecorder()
conn, mocks := getTestConnector(t, Config{
Name: "test",
Schema: "test",
Prefix: "/connector/",
URLPattern: "/{device_token}/{user_id}/{topic:.*}",
}, true, false)
mocks.manager.EXPECT().Filter(gomock.Eq(map[string]string{
"filter1": "value1",
"filter2": "value2",
})).Return([]Subscriber{})
req, err := http.NewRequest(
http.MethodGet,
"/connector/?filter1=value1&filter2=value2",
strings.NewReader(""))
a.NoError(err)
conn.ServeHTTP(recorder, req)
}
示例5: TestConnector_DeleteSubscription
func TestConnector_DeleteSubscription(t *testing.T) {
_, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
recorder := httptest.NewRecorder()
conn, mocks := getTestConnector(t, Config{
Name: "test",
Schema: "test",
Prefix: "/connector/",
URLPattern: "/{device_token}/{user_id}/{topic:.*}",
}, true, false)
subscriber := NewMockSubscriber(testutil.MockCtrl)
mocks.manager.EXPECT().Find(gomock.Eq(GenerateKey("/topic1", map[string]string{
"device_token": "device1",
"user_id": "user1",
}))).Return(subscriber)
mocks.manager.EXPECT().Remove(subscriber).Return(nil)
req, err := http.NewRequest(http.MethodDelete, "/connector/device1/user1/topic1", strings.NewReader(""))
a.NoError(err)
conn.ServeHTTP(recorder, req)
a.Equal(`{"unsubscribed":"/topic1"}`, recorder.Body.String())
time.Sleep(200 * time.Millisecond)
}
示例6: TestConnector_StartWithSubscriptions
func TestConnector_StartWithSubscriptions(t *testing.T) {
_, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
conn, mocks := getTestConnector(t, Config{
Name: "test",
Schema: "test",
Prefix: "/connector/",
URLPattern: "/{device_token}/{user_id}/{topic:.*}",
}, false, false)
entriesC := make(chan [2]string)
mocks.kvstore.EXPECT().Iterate(gomock.Eq("test"), gomock.Eq("")).Return(entriesC)
close(entriesC)
mocks.kvstore.EXPECT().Put(gomock.Any(), gomock.Any(), gomock.Any()).Times(4)
err := conn.Start()
a.NoError(err)
routes := make([]*router.Route, 0, 4)
mocks.router.EXPECT().Subscribe(gomock.Any()).Do(func(r *router.Route) (*router.Route, error) {
routes = append(routes, r)
return r, nil
}).Times(4)
// create subscriptions
createSubscriptions(t, conn, 4)
time.Sleep(100 * time.Millisecond)
mocks.sender.EXPECT().Send(gomock.Any()).Return(nil, nil).Times(4)
// send message in route channel
for i, r := range routes {
r.Deliver(&protocol.Message{
ID: uint64(i),
Path: protocol.Path("/topic"),
Body: []byte("test body"),
})
}
time.Sleep(100 * time.Millisecond)
err = conn.Stop()
a.NoError(err)
}
示例7: TestFullUpdateFlow
func TestFullUpdateFlow(t *testing.T) {
u, ctrl, cfg, mockfs, mockacs, mockhttp := mocks(t, nil)
defer ctrl.Finish()
var writtenFile bytes.Buffer
gomock.InOrder(
mockhttp.EXPECT().RoundTrip(mock_http.NewHTTPSimpleMatcher("GET", "https://s3.amazonaws.com/amazon-ecs-agent/update.tar")).Return(mock_http.SuccessResponse("update-tar-data"), nil),
mockfs.EXPECT().Create(gomock.Any()).Return(mock_os.NopReadWriteCloser(&writtenFile), nil),
mockfs.EXPECT().WriteFile("/tmp/test/desired-image", gomock.Any(), gomock.Any()).Return(nil),
mockacs.EXPECT().MakeRequest(gomock.Eq(&ecsacs.AckRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("mid").(*string),
})),
mockacs.EXPECT().MakeRequest(gomock.Eq(&ecsacs.AckRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("mid2").(*string),
})),
mockfs.EXPECT().Exit(exitcodes.ExitUpdate),
)
u.stageUpdateHandler()(&ecsacs.StageUpdateMessage{
ClusterArn: ptr("cluster").(*string),
ContainerInstanceArn: ptr("containerInstance").(*string),
MessageId: ptr("mid").(*string),
UpdateInfo: &ecsacs.UpdateInfo{
Location: ptr("https://s3.amazonaws.com/amazon-ecs-agent/update.tar").(*string),
Signature: ptr("6caeef375a080e3241781725b357890758d94b15d7ce63f6b2ff1cb5589f2007").(*string),
},
})
if writtenFile.String() != "update-tar-data" {
t.Error("Incorrect data written")
}
u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg))(&ecsacs.PerformUpdateMessage{
ClusterArn: ptr("cluster").(*string),
ContainerInstanceArn: ptr("containerInstance").(*string),
MessageId: ptr("mid2").(*string),
UpdateInfo: &ecsacs.UpdateInfo{
Location: ptr("https://s3.amazonaws.com/amazon-ecs-agent/update.tar").(*string),
Signature: ptr("c54518806ff4d14b680c35784113e1e7478491fe").(*string),
},
})
}
示例8: TestConnector_PostSubscription
// Ensure the subscription is started when posting
func TestConnector_PostSubscription(t *testing.T) {
_, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
recorder := httptest.NewRecorder()
conn, mocks := getTestConnector(t, Config{
Name: "test",
Schema: "test",
Prefix: "/connector/",
URLPattern: "/{device_token}/{user_id}/{topic:.*}",
}, true, false)
mocks.manager.EXPECT().Load().Return(nil)
mocks.manager.EXPECT().List().Return(make([]Subscriber, 0))
err := conn.Start()
a.NoError(err)
defer conn.Stop()
subscriber := NewMockSubscriber(testutil.MockCtrl)
mocks.manager.EXPECT().Create(gomock.Eq(protocol.Path("/topic1")), gomock.Eq(router.RouteParams{
"device_token": "device1",
"user_id": "user1",
})).Return(subscriber, nil)
subscriber.EXPECT().Loop(gomock.Any(), gomock.Any())
r := router.NewRoute(router.RouteConfig{
Path: protocol.Path("topic1"),
RouteParams: router.RouteParams{
"device_token": "device1",
"user_id": "user1",
},
})
subscriber.EXPECT().Route().Return(r)
mocks.router.EXPECT().Subscribe(gomock.Eq(r)).Return(r, nil)
req, err := http.NewRequest(http.MethodPost, "/connector/device1/user1/topic1", strings.NewReader(""))
a.NoError(err)
conn.ServeHTTP(recorder, req)
a.Equal(`{"subscribed":"/topic1"}`, recorder.Body.String())
time.Sleep(100 * time.Millisecond)
}
示例9: TestGetPlansByGroupHandler
func TestGetPlansByGroupHandler(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
u := newTestUser(false)
g := uuid.New()
u.Groups = []string{g}
p, _ := newPlan(u, 2016, 6, goals{goal{"Yay!", 0}})
db := NewMockdb(ctrl)
db.EXPECT().LoadPlans(gomock.Eq(2016), gomock.Eq(6)).Return(plans{*p}, nil)
db.EXPECT().LoadAllUsers().Return(users{*u}, nil)
rec := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/api/groups/plans/2016/6/"+g, nil)
handler := makePlansByGroupHandler(getPlansByGroupHandler)
handler(rec, req, u, db)
if rec.Code != http.StatusOK {
t.Error("got", rec.Code, "expected", http.StatusOK)
}
}
示例10: TestHandleTokenEndpointRequest
func TestHandleTokenEndpointRequest(t *testing.T) {
ctrl := gomock.NewController(t)
store := internal.NewMockAuthorizeCodeGrantStorage(ctrl)
chgen := internal.NewMockEnigma(ctrl)
areq := internal.NewMockAccessRequester(ctrl)
aresp := internal.NewMockAccessResponder(ctrl)
//mockcl := internal.NewMockClient(ctrl)
defer ctrl.Finish()
h := AuthorizeExplicitGrantTypeHandler{
Store: store,
Enigma: chgen,
}
for k, c := range []struct {
mock func()
req *http.Request
expectErr error
}{
{
mock: func() {
areq.EXPECT().GetGrantType().Return("13245678")
},
},
{
mock: func() {
areq.EXPECT().GetGrantType().Return("authorization_code")
areq.EXPECT().GetClient().Return(&client.SecureClient{})
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, errors.New("foo"))
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{PostForm: url.Values{}},
mock: func() {
areq.EXPECT().GetGrantType().Return("authorization_code")
areq.EXPECT().GetClient().Return(&client.SecureClient{})
areq.EXPECT().GetClient().Return(&client.SecureClient{})
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
store.EXPECT().GetAuthorizeCodeSession(gomock.Any(), gomock.Any()).Return(nil, errors.New(""))
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{PostForm: url.Values{}},
mock: func() {
areq.EXPECT().GetGrantType().Return("authorization_code")
areq.EXPECT().GetClient().Return(&client.SecureClient{})
areq.EXPECT().GetClient().Return(&client.SecureClient{})
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
store.EXPECT().GetAuthorizeCodeSession(gomock.Any(), gomock.Any()).Return(&fosite.AuthorizeRequest{}, nil)
store.EXPECT().DeleteAuthorizeCodeSession(gomock.Any()).Return(nil)
store.EXPECT().CreateAccessTokenSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New(""))
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{PostForm: url.Values{}},
mock: func() {
areq.EXPECT().GetGrantType().Return("authorization_code")
areq.EXPECT().GetClient().Return(&client.SecureClient{})
areq.EXPECT().GetClient().Return(&client.SecureClient{})
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
store.EXPECT().DeleteAuthorizeCodeSession(gomock.Any()).Return(nil)
store.EXPECT().GetAuthorizeCodeSession(gomock.Any(), gomock.Any()).Return(&fosite.AuthorizeRequest{}, nil)
store.EXPECT().CreateAccessTokenSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
store.EXPECT().CreateRefreshTokenSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New(""))
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{PostForm: url.Values{}},
mock: func() {
areq.EXPECT().GetGrantType().Return("authorization_code")
areq.EXPECT().GetGrantedScopes()
areq.EXPECT().GetClient().Return(&client.SecureClient{})
areq.EXPECT().GetClient().Return(&client.SecureClient{})
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
chgen.EXPECT().GenerateChallenge(gomock.Any()).Return(&enigma.Challenge{}, nil)
aresp.EXPECT().SetAccessToken(gomock.Eq("."))
aresp.EXPECT().SetTokenType(gomock.Eq("bearer"))
aresp.EXPECT().SetExtra(gomock.Eq("refresh_token"), gomock.Any())
aresp.EXPECT().SetExtra(gomock.Eq("expires_in"), gomock.Any())
aresp.EXPECT().SetExtra(gomock.Eq("state"), gomock.Any())
aresp.EXPECT().SetExtra(gomock.Eq("scope"), gomock.Any())
store.EXPECT().DeleteAuthorizeCodeSession(gomock.Any()).Return(nil)
store.EXPECT().GetAuthorizeCodeSession(gomock.Any(), gomock.Any()).Return(&fosite.AuthorizeRequest{}, nil)
store.EXPECT().CreateAccessTokenSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
store.EXPECT().CreateRefreshTokenSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
},
},
//.........这里部分代码省略.........
示例11: TestNewerUpdateMessages
func TestNewerUpdateMessages(t *testing.T) {
u, ctrl, cfg, mockfs, mockacs, mockhttp := mocks(t, nil)
defer ctrl.Finish()
var writtenFile bytes.Buffer
gomock.InOrder(
mockhttp.EXPECT().RoundTrip(mock_http.NewHTTPSimpleMatcher("GET", "https://s3.amazonaws.com/amazon-ecs-agent/update.tar")).Return(mock_http.SuccessResponse("update-tar-data"), nil),
mockfs.EXPECT().Create(gomock.Any()).Return(mock_os.NopReadWriteCloser(&writtenFile), nil),
mockfs.EXPECT().WriteFile("/tmp/test/desired-image", gomock.Any(), gomock.Any()).Return(nil),
mockacs.EXPECT().MakeRequest(gomock.Eq(&ecsacs.AckRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("StageMID").(*string),
})),
mockacs.EXPECT().MakeRequest(&nackRequestMatcher{&ecsacs.NackRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("StageMID").(*string),
Reason: ptr("New update arrived: StageMIDNew").(*string),
}}),
mockhttp.EXPECT().RoundTrip(mock_http.NewHTTPSimpleMatcher("GET", "https://s3.amazonaws.com/amazon-ecs-agent/new.tar")).Return(mock_http.SuccessResponse("newer-update-tar-data"), nil),
mockfs.EXPECT().Create(gomock.Any()).Return(mock_os.NopReadWriteCloser(&writtenFile), nil),
mockfs.EXPECT().WriteFile("/tmp/test/desired-image", gomock.Any(), gomock.Any()).Return(nil),
mockacs.EXPECT().MakeRequest(gomock.Eq(&ecsacs.AckRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("StageMIDNew").(*string),
})),
mockacs.EXPECT().MakeRequest(gomock.Eq(&ecsacs.AckRequest{
Cluster: ptr("cluster").(*string),
ContainerInstance: ptr("containerInstance").(*string),
MessageId: ptr("mid2").(*string),
})),
mockfs.EXPECT().Exit(exitcodes.ExitUpdate),
)
u.stageUpdateHandler()(&ecsacs.StageUpdateMessage{
ClusterArn: ptr("cluster").(*string),
ContainerInstanceArn: ptr("containerInstance").(*string),
MessageId: ptr("StageMID").(*string),
UpdateInfo: &ecsacs.UpdateInfo{
Location: ptr("https://s3.amazonaws.com/amazon-ecs-agent/update.tar").(*string),
Signature: ptr("6caeef375a080e3241781725b357890758d94b15d7ce63f6b2ff1cb5589f2007").(*string),
},
})
if writtenFile.String() != "update-tar-data" {
t.Error("Incorrect data written")
}
writtenFile.Reset()
// Never perform, make sure a new hash results in a new stage
u.stageUpdateHandler()(&ecsacs.StageUpdateMessage{
ClusterArn: ptr("cluster").(*string),
ContainerInstanceArn: ptr("containerInstance").(*string),
MessageId: ptr("StageMIDNew").(*string),
UpdateInfo: &ecsacs.UpdateInfo{
Location: ptr("https://s3.amazonaws.com/amazon-ecs-agent/new.tar").(*string),
Signature: ptr("9c6ea7bd7d49f95b6d516517e453b965897109bf8a1d6ff3a6e57287049eb2de").(*string),
},
})
if writtenFile.String() != "newer-update-tar-data" {
t.Error("Incorrect data written")
}
u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg))(&ecsacs.PerformUpdateMessage{
ClusterArn: ptr("cluster").(*string),
ContainerInstanceArn: ptr("containerInstance").(*string),
MessageId: ptr("mid2").(*string),
UpdateInfo: &ecsacs.UpdateInfo{
Location: ptr("https://s3.amazonaws.com/amazon-ecs-agent/update.tar").(*string),
Signature: ptr("c54518806ff4d14b680c35784113e1e7478491fe").(*string),
},
})
}
示例12: TestHandleAuthorizeEndpointRequest
func TestHandleAuthorizeEndpointRequest(t *testing.T) {
ctrl := gomock.NewController(t)
store := internal.NewMockAuthorizeCodeGrantStorage(ctrl)
chgen := internal.NewMockEnigma(ctrl)
areq := internal.NewMockAuthorizeRequester(ctrl)
aresp := internal.NewMockAuthorizeResponder(ctrl)
defer ctrl.Finish()
h := AuthorizeExplicitGrantTypeHandler{
Store: store,
Enigma: chgen,
}
for k, c := range []struct {
mock func()
req *http.Request
expectErr error
}{
{
mock: func() {
areq.EXPECT().GetResponseTypes().Return(fosite.Arguments{})
},
},
{
mock: func() {
areq.EXPECT().GetResponseTypes().Return(fosite.Arguments{"foo"})
},
},
{
mock: func() {
areq.EXPECT().GetResponseTypes().Return(fosite.Arguments{"code"})
areq.EXPECT().GetClient().Return(&client.SecureClient{Secret: []byte("foosecret")})
chgen.EXPECT().GenerateChallenge(gomock.Eq([]byte("foosecret"))).Return(nil, fosite.ErrServerError)
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{Form: url.Values{"redirect_uri": {"foobar"}}},
mock: func() {
areq.EXPECT().GetResponseTypes().Return(fosite.Arguments{"code"})
areq.EXPECT().GetClient().Return(&client.SecureClient{Secret: []byte("foosecret")})
chgen.EXPECT().GenerateChallenge(gomock.Eq([]byte("foosecret"))).Return(&enigma.Challenge{}, nil)
store.EXPECT().CreateAuthorizeCodeSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(fosite.ErrTemporarilyUnavailable)
},
expectErr: fosite.ErrServerError,
},
{
req: &http.Request{Form: url.Values{"redirect_uri": {"foobar"}}},
mock: func() {
areq.EXPECT().GetResponseTypes().Return(fosite.Arguments{"code"})
areq.EXPECT().GetClient().Return(&client.SecureClient{Secret: []byte("foosecret")})
chgen.EXPECT().GenerateChallenge(gomock.Eq([]byte("foosecret"))).Return(&enigma.Challenge{Key: "foo", Signature: "bar"}, nil)
store.EXPECT().CreateAuthorizeCodeSession(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
aresp.EXPECT().AddQuery(gomock.Eq("code"), gomock.Eq("foo.bar"))
aresp.EXPECT().AddQuery(gomock.Eq("scope"), gomock.Any())
aresp.EXPECT().AddQuery(gomock.Eq("state"), gomock.Any())
areq.EXPECT().SetResponseTypeHandled(gomock.Eq("code"))
areq.EXPECT().GetGrantedScopes()
areq.EXPECT().GetState()
},
},
} {
c.mock()
err := h.HandleAuthorizeEndpointRequest(nil, c.req, areq, aresp, nil)
assert.True(t, errors.Is(c.expectErr, err), "%d\n%s\n%s", k, err, c.expectErr)
t.Logf("Passed test case %d", k)
}
}
示例13: TestNewAccessRequest
func TestNewAccessRequest(t *testing.T) {
ctrl := gomock.NewController(t)
store := internal.NewMockStorage(ctrl)
client := internal.NewMockClient(ctrl)
handler := internal.NewMockTokenEndpointHandler(ctrl)
hasher := internal.NewMockHasher(ctrl)
defer ctrl.Finish()
fosite := &Fosite{Store: store, Hasher: hasher}
for k, c := range []struct {
header http.Header
form url.Values
mock func()
method string
expectErr error
expect *AccessRequest
handlers TokenEndpointHandlers
}{
{
header: http.Header{},
expectErr: ErrInvalidRequest,
method: "POST",
mock: func() {},
},
{
header: http.Header{},
method: "POST",
form: url.Values{
"grant_type": {"foo"},
},
mock: func() {},
expectErr: ErrInvalidRequest,
},
{
header: http.Header{},
method: "POST",
form: url.Values{
"grant_type": {"foo"},
"client_id": {"foo"},
},
expectErr: ErrInvalidRequest,
mock: func() {},
},
{
header: http.Header{
"Authorization": {basicAuth("foo", "bar")},
},
method: "POST",
form: url.Values{
"grant_type": {"foo"},
},
expectErr: ErrInvalidClient,
mock: func() {
store.EXPECT().GetClient(gomock.Eq("foo")).Return(nil, errors.New(""))
},
},
{
header: http.Header{
"Authorization": {basicAuth("foo", "bar")},
},
method: "GET",
form: url.Values{
"grant_type": {"foo"},
},
expectErr: ErrInvalidRequest,
mock: func() {},
},
{
header: http.Header{
"Authorization": {basicAuth("foo", "bar")},
},
method: "POST",
form: url.Values{
"grant_type": {"foo"},
},
expectErr: ErrInvalidClient,
mock: func() {
store.EXPECT().GetClient(gomock.Eq("foo")).Return(nil, errors.New(""))
},
},
{
header: http.Header{
"Authorization": {basicAuth("foo", "bar")},
},
method: "POST",
form: url.Values{
"grant_type": {"foo"},
},
expectErr: ErrInvalidClient,
mock: func() {
store.EXPECT().GetClient(gomock.Eq("foo")).Return(client, nil)
client.EXPECT().GetHashedSecret().Return([]byte("foo"))
hasher.EXPECT().Compare(gomock.Eq([]byte("foo")), gomock.Eq([]byte("bar"))).Return(errors.New(""))
},
},
{
header: http.Header{
"Authorization": {basicAuth("foo", "bar")},
},
method: "POST",
//.........这里部分代码省略.........
示例14: Test_SendOneSms
func Test_SendOneSms(t *testing.T) {
ctrl, finish := testutil.NewMockCtrl(t)
defer finish()
defer testutil.EnableDebugForMethod()()
a := assert.New(t)
mockSmsSender := NewMockSender(ctrl)
kvStore := kvstore.NewMemoryKVStore()
a.NotNil(kvStore)
routerMock := NewMockRouter(testutil.MockCtrl)
routerMock.EXPECT().KVStore().AnyTimes().Return(kvStore, nil)
msgStore := dummystore.New(kvStore)
routerMock.EXPECT().MessageStore().AnyTimes().Return(msgStore, nil)
topic := "/sms"
worker := 1
config := Config{
Workers: &worker,
SMSTopic: &topic,
Name: "test_gateway",
Schema: SMSSchema,
}
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(r *router.Route) (*router.Route, error) {
a.Equal(topic, string(r.Path))
return r, nil
})
gw, err := New(routerMock, mockSmsSender, config)
a.NoError(err)
err = gw.Start()
a.NoError(err)
sms := NexmoSms{
To: "toNumber",
From: "FromNUmber",
Text: "body",
}
d, err := json.Marshal(&sms)
a.NoError(err)
msg := protocol.Message{
Path: protocol.Path(topic),
ID: uint64(4),
Body: d,
}
mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Return(nil)
a.NotNil(gw.route)
gw.route.Deliver(&msg)
time.Sleep(100 * time.Millisecond)
err = gw.Stop()
a.NoError(err)
err = gw.ReadLastID()
a.NoError(err)
time.Sleep(100 * time.Millisecond)
}
示例15: Test_Restart
func Test_Restart(t *testing.T) {
ctrl, finish := testutil.NewMockCtrl(t)
defer finish()
defer testutil.EnableDebugForMethod()()
a := assert.New(t)
mockSmsSender := NewMockSender(ctrl)
kvStore := kvstore.NewMemoryKVStore()
a.NotNil(kvStore)
routerMock := NewMockRouter(testutil.MockCtrl)
routerMock.EXPECT().KVStore().AnyTimes().Return(kvStore, nil)
msgStore := NewMockMessageStore(ctrl)
routerMock.EXPECT().MessageStore().AnyTimes().Return(msgStore, nil)
topic := "/sms"
worker := 1
config := Config{
Workers: &worker,
SMSTopic: &topic,
Name: "test_gateway",
Schema: SMSSchema,
}
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(r *router.Route) (*router.Route, error) {
a.Equal(strings.Split(topic, "/")[1], r.Path.Partition())
return r, nil
}).Times(2)
gw, err := New(routerMock, mockSmsSender, config)
a.NoError(err)
err = gw.Start()
a.NoError(err)
sms := NexmoSms{
To: "toNumber",
From: "FromNUmber",
Text: "body",
}
d, err := json.Marshal(&sms)
a.NoError(err)
msg := protocol.Message{
Path: protocol.Path(topic),
UserID: "samsa",
ApplicationID: "sms",
ID: uint64(4),
Body: d,
}
//TODO MARIAN FIX THIS TEST
//msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(0), nil)
//msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(4), nil)
//msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(4), nil)
mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Times(1).Return(ErrNoSMSSent)
//routerMock.EXPECT().Fetch(gomock.Any()).Do(func(r *store.FetchRequest) {
// go func() {
//
// logger.WithField("r.Partition", r.Partition).Info("----")
//
// a.Equal(strings.Split(topic, "/")[1], r.Partition)
//
// r.StartC <- 1
//
// r.MessageC <- &store.FetchedMessage{ID: uint64(4), Message: msg.Bytes()}
// close(r.MessageC)
// }()
//})
doneC := make(chan bool)
routerMock.EXPECT().Done().AnyTimes().Return(doneC)
//
//mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Return(nil)
a.NotNil(gw.route)
gw.route.Deliver(&msg)
time.Sleep(100 * time.Millisecond)
}