From 9f6a124c856292511726e679ebfbb96e0d640046 Mon Sep 17 00:00:00 2001 From: Tom Clegg Date: Tue, 18 Jun 2019 10:52:45 -0400 Subject: [PATCH] 14287: Unit-test router with stubbed API. Arvados-DCO-1.1-Signed-off-by: Tom Clegg --- lib/controller/router/checker.go | 27 ++++ lib/controller/router/router.go | 7 +- lib/controller/router/router_test.go | 195 ++++++++++++++++++++++----- sdk/go/arvadostest/api.go | 135 +++++++++++++++++++ 4 files changed, 326 insertions(+), 38 deletions(-) create mode 100644 lib/controller/router/checker.go create mode 100644 sdk/go/arvadostest/api.go diff --git a/lib/controller/router/checker.go b/lib/controller/router/checker.go new file mode 100644 index 0000000000..b9fec9168e --- /dev/null +++ b/lib/controller/router/checker.go @@ -0,0 +1,27 @@ +// Copyright (C) The Arvados Authors. All rights reserved. +// +// SPDX-License-Identifier: AGPL-3.0 + +package router + +import ( + "reflect" + "runtime" + + check "gopkg.in/check.v1" +) + +var isMethodNamed check.Checker = &chkIsMethodNamed{ + CheckerInfo: &check.CheckerInfo{ + Name: "isMethodNamed", + Params: []string{"obtained", "expected"}, + }, +} + +type chkIsMethodNamed struct{ *check.CheckerInfo } + +func (*chkIsMethodNamed) Check(params []interface{}, names []string) (bool, string) { + methodName := runtime.FuncForPC(reflect.ValueOf(params[0]).Pointer()).Name() + regex := `.*\)\.` + params[1].(string) + `(-.*)?` + return check.Matches.Check([]interface{}{methodName, regex}, names) +} diff --git a/lib/controller/router/router.go b/lib/controller/router/router.go index 1d08046b69..909667c545 100644 --- a/lib/controller/router/router.go +++ b/lib/controller/router/router.go @@ -29,11 +29,11 @@ func New(cluster *arvados.Cluster) *router { mux: httprouter.New(), fed: federation.New(cluster), } - rtr.addRoutes(cluster) + rtr.addRoutes() return rtr } -func (rtr *router) addRoutes(cluster *arvados.Cluster) { +func (rtr *router) addRoutes() { for _, route := range []struct { endpoint arvados.APIEndpoint defaultOpts func() interface{} @@ -248,6 +248,9 @@ func (rtr *router) addRoutes(cluster *arvados.Cluster) { rtr.mux.NotFound = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { httpserver.Errors(w, []string{"API endpoint not found"}, http.StatusNotFound) }) + rtr.mux.MethodNotAllowed = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + httpserver.Errors(w, []string{"API endpoint not found"}, http.StatusMethodNotAllowed) + }) } func (rtr *router) ServeHTTP(w http.ResponseWriter, r *http.Request) { diff --git a/lib/controller/router/router_test.go b/lib/controller/router/router_test.go index 63e5678ec7..4e6b161733 100644 --- a/lib/controller/router/router_test.go +++ b/lib/controller/router/router_test.go @@ -17,6 +17,7 @@ import ( "git.curoverse.com/arvados.git/sdk/go/arvados" "git.curoverse.com/arvados.git/sdk/go/arvadostest" + "github.com/julienschmidt/httprouter" check "gopkg.in/check.v1" ) @@ -28,41 +29,148 @@ func Test(t *testing.T) { var _ = check.Suite(&RouterSuite{}) type RouterSuite struct { - rtr *router + rtr *router + stub arvadostest.APIStub } func (s *RouterSuite) SetUpTest(c *check.C) { + s.stub = arvadostest.APIStub{} + s.rtr = &router{ + mux: httprouter.New(), + fed: &s.stub, + } + s.rtr.addRoutes() +} + +func (s *RouterSuite) TestOptions(c *check.C) { + token := arvadostest.ActiveToken + for _, trial := range []struct { + method string + path string + header http.Header + body string + shouldStatus int // zero value means 200 + shouldCall string + withOptions interface{} + }{ + { + method: "GET", + path: "/arvados/v1/collections/" + arvadostest.FooCollection, + shouldCall: "CollectionGet", + withOptions: arvados.GetOptions{UUID: arvadostest.FooCollection}, + }, + { + method: "PUT", + path: "/arvados/v1/collections/" + arvadostest.FooCollection, + shouldCall: "CollectionUpdate", + withOptions: arvados.UpdateOptions{UUID: arvadostest.FooCollection}, + }, + { + method: "PATCH", + path: "/arvados/v1/collections/" + arvadostest.FooCollection, + shouldCall: "CollectionUpdate", + withOptions: arvados.UpdateOptions{UUID: arvadostest.FooCollection}, + }, + { + method: "DELETE", + path: "/arvados/v1/collections/" + arvadostest.FooCollection, + shouldCall: "CollectionDelete", + withOptions: arvados.DeleteOptions{UUID: arvadostest.FooCollection}, + }, + { + method: "POST", + path: "/arvados/v1/collections", + shouldCall: "CollectionCreate", + withOptions: arvados.CreateOptions{}, + }, + { + method: "GET", + path: "/arvados/v1/collections", + shouldCall: "CollectionList", + withOptions: arvados.ListOptions{Limit: -1}, + }, + { + method: "GET", + path: "/arvados/v1/collections?limit=123&offset=456&include_trash=true&include_old_versions=1", + shouldCall: "CollectionList", + withOptions: arvados.ListOptions{Limit: 123, Offset: 456, IncludeTrash: true, IncludeOldVersions: true}, + }, + { + method: "POST", + path: "/arvados/v1/collections?limit=123&_method=GET", + body: `{"offset":456,"include_trash":true,"include_old_versions":true}`, + shouldCall: "CollectionList", + withOptions: arvados.ListOptions{Limit: 123, Offset: 456, IncludeTrash: true, IncludeOldVersions: true}, + }, + { + method: "POST", + path: "/arvados/v1/collections?limit=123", + body: "offset=456&include_trash=true&include_old_versions=1&_method=GET", + header: http.Header{"Content-Type": {"application/x-www-form-urlencoded"}}, + shouldCall: "CollectionList", + withOptions: arvados.ListOptions{Limit: 123, Offset: 456, IncludeTrash: true, IncludeOldVersions: true}, + }, + { + method: "PATCH", + path: "/arvados/v1/collections", + shouldStatus: http.StatusMethodNotAllowed, + }, + { + method: "PUT", + path: "/arvados/v1/collections", + shouldStatus: http.StatusMethodNotAllowed, + }, + { + method: "DELETE", + path: "/arvados/v1/collections", + shouldStatus: http.StatusMethodNotAllowed, + }, + } { + // Reset calls captured in previous trial + s.stub = arvadostest.APIStub{} + + c.Logf("trial: %#v", trial) + _, rr, _ := doRequest(c, s.rtr, token, trial.method, trial.path, trial.header, bytes.NewBufferString(trial.body)) + if trial.shouldStatus == 0 { + c.Check(rr.Code, check.Equals, http.StatusOK) + } else { + c.Check(rr.Code, check.Equals, trial.shouldStatus) + } + calls := s.stub.Calls(nil) + if trial.shouldCall == "" { + c.Check(calls, check.HasLen, 0) + } else if len(calls) != 1 { + c.Check(calls, check.HasLen, 1) + } else { + c.Check(calls[0].Method, isMethodNamed, trial.shouldCall) + c.Check(calls[0].Options, check.DeepEquals, trial.withOptions) + } + } +} + +var _ = check.Suite(&RouterIntegrationSuite{}) + +type RouterIntegrationSuite struct { + rtr *router +} + +func (s *RouterIntegrationSuite) SetUpTest(c *check.C) { cluster := &arvados.Cluster{} cluster.TLS.Insecure = true arvadostest.SetServiceURL(&cluster.Services.RailsAPI, "https://"+os.Getenv("ARVADOS_TEST_API_HOST")) s.rtr = New(cluster) } -func (s *RouterSuite) TearDownSuite(c *check.C) { +func (s *RouterIntegrationSuite) TearDownSuite(c *check.C) { err := arvados.NewClientFromEnv().RequestAndDecode(nil, "POST", "database/reset", nil, nil) c.Check(err, check.IsNil) } -func (s *RouterSuite) doRequest(c *check.C, token, method, path string, hdrs http.Header, body io.Reader) (*http.Request, *httptest.ResponseRecorder, map[string]interface{}) { - req := httptest.NewRequest(method, path, body) - for k, v := range hdrs { - req.Header[k] = v - } - req.Header.Set("Authorization", "Bearer "+token) - rr := httptest.NewRecorder() - s.rtr.ServeHTTP(rr, req) - c.Logf("response body: %s", rr.Body.String()) - var jresp map[string]interface{} - err := json.Unmarshal(rr.Body.Bytes(), &jresp) - c.Check(err, check.IsNil) - return req, rr, jresp -} - -func (s *RouterSuite) TestCollectionResponses(c *check.C) { +func (s *RouterIntegrationSuite) TestCollectionResponses(c *check.C) { token := arvadostest.ActiveTokenV2 // Check "get collection" response has "kind" key - _, rr, jresp := s.doRequest(c, token, "GET", `/arvados/v1/collections`, nil, bytes.NewBufferString(`{"include_trash":true}`)) + _, rr, jresp := doRequest(c, s.rtr, token, "GET", `/arvados/v1/collections`, nil, bytes.NewBufferString(`{"include_trash":true}`)) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["items"], check.FitsTypeOf, []interface{}{}) c.Check(jresp["kind"], check.Equals, "arvados#collectionList") @@ -76,7 +184,7 @@ func (s *RouterSuite) TestCollectionResponses(c *check.C) { `,"select":["name"]`, `,"select":["uuid"]`, } { - _, rr, jresp = s.doRequest(c, token, "GET", `/arvados/v1/collections`, nil, bytes.NewBufferString(`{"where":{"uuid":["`+arvadostest.FooCollection+`"]}`+selectj+`}`)) + _, rr, jresp = doRequest(c, s.rtr, token, "GET", `/arvados/v1/collections`, nil, bytes.NewBufferString(`{"where":{"uuid":["`+arvadostest.FooCollection+`"]}`+selectj+`}`)) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["items"], check.FitsTypeOf, []interface{}{}) c.Check(jresp["items_available"], check.FitsTypeOf, float64(0)) @@ -101,22 +209,22 @@ func (s *RouterSuite) TestCollectionResponses(c *check.C) { } // Check "create collection" response has "kind" key - _, rr, jresp = s.doRequest(c, token, "POST", `/arvados/v1/collections`, http.Header{"Content-Type": {"application/x-www-form-urlencoded"}}, bytes.NewBufferString(`ensure_unique_name=true`)) + _, rr, jresp = doRequest(c, s.rtr, token, "POST", `/arvados/v1/collections`, http.Header{"Content-Type": {"application/x-www-form-urlencoded"}}, bytes.NewBufferString(`ensure_unique_name=true`)) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["uuid"], check.FitsTypeOf, "") c.Check(jresp["kind"], check.Equals, "arvados#collection") } -func (s *RouterSuite) TestContainerList(c *check.C) { +func (s *RouterIntegrationSuite) TestContainerList(c *check.C) { token := arvadostest.ActiveTokenV2 - _, rr, jresp := s.doRequest(c, token, "GET", `/arvados/v1/containers?limit=0`, nil, nil) + _, rr, jresp := doRequest(c, s.rtr, token, "GET", `/arvados/v1/containers?limit=0`, nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["items_available"], check.FitsTypeOf, float64(0)) c.Check(jresp["items_available"].(float64) > 2, check.Equals, true) c.Check(jresp["items"], check.HasLen, 0) - _, rr, jresp = s.doRequest(c, token, "GET", `/arvados/v1/containers?limit=2&select=["uuid","command"]`, nil, nil) + _, rr, jresp = doRequest(c, s.rtr, token, "GET", `/arvados/v1/containers?limit=2&select=["uuid","command"]`, nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["items_available"], check.FitsTypeOf, float64(0)) c.Check(jresp["items_available"].(float64) > 2, check.Equals, true) @@ -127,7 +235,7 @@ func (s *RouterSuite) TestContainerList(c *check.C) { c.Check(item0["command"].([]interface{})[0], check.FitsTypeOf, "") c.Check(item0["mounts"], check.IsNil) - _, rr, jresp = s.doRequest(c, token, "GET", `/arvados/v1/containers`, nil, nil) + _, rr, jresp = doRequest(c, s.rtr, token, "GET", `/arvados/v1/containers`, nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["items_available"], check.FitsTypeOf, float64(0)) c.Check(jresp["items_available"].(float64) > 2, check.Equals, true) @@ -140,31 +248,31 @@ func (s *RouterSuite) TestContainerList(c *check.C) { c.Check(item0["mounts"], check.NotNil) } -func (s *RouterSuite) TestContainerLock(c *check.C) { +func (s *RouterIntegrationSuite) TestContainerLock(c *check.C) { uuid := arvadostest.QueuedContainerUUID token := arvadostest.AdminToken - _, rr, jresp := s.doRequest(c, token, "POST", "/arvados/v1/containers/"+uuid+"/lock", nil, nil) + _, rr, jresp := doRequest(c, s.rtr, token, "POST", "/arvados/v1/containers/"+uuid+"/lock", nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["uuid"], check.HasLen, 27) c.Check(jresp["state"], check.Equals, "Locked") - _, rr, jresp = s.doRequest(c, token, "POST", "/arvados/v1/containers/"+uuid+"/lock", nil, nil) + _, rr, jresp = doRequest(c, s.rtr, token, "POST", "/arvados/v1/containers/"+uuid+"/lock", nil, nil) c.Check(rr.Code, check.Equals, http.StatusUnprocessableEntity) c.Check(rr.Body.String(), check.Not(check.Matches), `.*"uuid":.*`) - _, rr, jresp = s.doRequest(c, token, "POST", "/arvados/v1/containers/"+uuid+"/unlock", nil, nil) + _, rr, jresp = doRequest(c, s.rtr, token, "POST", "/arvados/v1/containers/"+uuid+"/unlock", nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["uuid"], check.HasLen, 27) c.Check(jresp["state"], check.Equals, "Queued") c.Check(jresp["environment"], check.IsNil) - _, rr, jresp = s.doRequest(c, token, "POST", "/arvados/v1/containers/"+uuid+"/unlock", nil, nil) + _, rr, jresp = doRequest(c, s.rtr, token, "POST", "/arvados/v1/containers/"+uuid+"/unlock", nil, nil) c.Check(rr.Code, check.Equals, http.StatusUnprocessableEntity) c.Check(jresp["uuid"], check.IsNil) } -func (s *RouterSuite) TestFullTimestampsInResponse(c *check.C) { +func (s *RouterIntegrationSuite) TestFullTimestampsInResponse(c *check.C) { uuid := arvadostest.CollectionReplicationDesired2Confirmed2UUID token := arvadostest.ActiveTokenV2 - _, rr, jresp := s.doRequest(c, token, "GET", `/arvados/v1/collections/`+uuid, nil, nil) + _, rr, jresp := doRequest(c, s.rtr, token, "GET", `/arvados/v1/collections/`+uuid, nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(jresp["uuid"], check.Equals, uuid) expectNS := map[string]int{ @@ -181,7 +289,7 @@ func (s *RouterSuite) TestFullTimestampsInResponse(c *check.C) { } } -func (s *RouterSuite) TestSelectParam(c *check.C) { +func (s *RouterIntegrationSuite) TestSelectParam(c *check.C) { uuid := arvadostest.QueuedContainerUUID token := arvadostest.ActiveTokenV2 for _, sel := range [][]string{ @@ -191,7 +299,7 @@ func (s *RouterSuite) TestSelectParam(c *check.C) { } { j, err := json.Marshal(sel) c.Assert(err, check.IsNil) - _, rr, resp := s.doRequest(c, token, "GET", "/arvados/v1/containers/"+uuid+"?select="+string(j), nil, nil) + _, rr, resp := doRequest(c, s.rtr, token, "GET", "/arvados/v1/containers/"+uuid+"?select="+string(j), nil, nil) c.Check(rr.Code, check.Equals, http.StatusOK) c.Check(resp["kind"], check.Equals, "arvados#container") @@ -203,7 +311,7 @@ func (s *RouterSuite) TestSelectParam(c *check.C) { } } -func (s *RouterSuite) TestRouteNotFound(c *check.C) { +func (s *RouterIntegrationSuite) TestRouteNotFound(c *check.C) { token := arvadostest.ActiveTokenV2 req := (&testReq{ method: "POST", @@ -222,7 +330,7 @@ func (s *RouterSuite) TestRouteNotFound(c *check.C) { c.Check(j["errors"].([]interface{})[0], check.Equals, "API endpoint not found") } -func (s *RouterSuite) TestCORS(c *check.C) { +func (s *RouterIntegrationSuite) TestCORS(c *check.C) { token := arvadostest.ActiveTokenV2 req := (&testReq{ method: "OPTIONS", @@ -270,3 +378,18 @@ func (s *RouterSuite) TestCORS(c *check.C) { c.Check(rr.Result().Header.Get("Access-Control-Allow-Headers"), check.Equals, "") } } + +func doRequest(c *check.C, rtr http.Handler, token, method, path string, hdrs http.Header, body io.Reader) (*http.Request, *httptest.ResponseRecorder, map[string]interface{}) { + req := httptest.NewRequest(method, path, body) + for k, v := range hdrs { + req.Header[k] = v + } + req.Header.Set("Authorization", "Bearer "+token) + rr := httptest.NewRecorder() + rtr.ServeHTTP(rr, req) + c.Logf("response body: %s", rr.Body.String()) + var jresp map[string]interface{} + err := json.Unmarshal(rr.Body.Bytes(), &jresp) + c.Check(err, check.IsNil) + return req, rr, jresp +} diff --git a/sdk/go/arvadostest/api.go b/sdk/go/arvadostest/api.go new file mode 100644 index 0000000000..a3cacf3f6c --- /dev/null +++ b/sdk/go/arvadostest/api.go @@ -0,0 +1,135 @@ +// Copyright (C) The Arvados Authors. All rights reserved. +// +// SPDX-License-Identifier: Apache-2.0 + +package arvadostest + +import ( + "context" + "errors" + "sync" + + "git.curoverse.com/arvados.git/sdk/go/arvados" +) + +var ErrStubUnimplemented = errors.New("stub unimplemented") + +type APIStub struct { + // The error to return from every stubbed API method. + Error error + calls []APIStubCall + mtx sync.Mutex +} + +func (as *APIStub) CollectionCreate(ctx context.Context, options arvados.CreateOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionCreate, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) CollectionUpdate(ctx context.Context, options arvados.UpdateOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionUpdate, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) CollectionGet(ctx context.Context, options arvados.GetOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionGet, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) CollectionList(ctx context.Context, options arvados.ListOptions) (arvados.CollectionList, error) { + as.appendCall(as.CollectionList, ctx, options) + return arvados.CollectionList{}, as.Error +} +func (as *APIStub) CollectionProvenance(ctx context.Context, options arvados.GetOptions) (map[string]interface{}, error) { + as.appendCall(as.CollectionProvenance, ctx, options) + return nil, as.Error +} +func (as *APIStub) CollectionUsedBy(ctx context.Context, options arvados.GetOptions) (map[string]interface{}, error) { + as.appendCall(as.CollectionUsedBy, ctx, options) + return nil, as.Error +} +func (as *APIStub) CollectionDelete(ctx context.Context, options arvados.DeleteOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionDelete, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) CollectionTrash(ctx context.Context, options arvados.DeleteOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionTrash, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) CollectionUntrash(ctx context.Context, options arvados.UntrashOptions) (arvados.Collection, error) { + as.appendCall(as.CollectionUntrash, ctx, options) + return arvados.Collection{}, as.Error +} +func (as *APIStub) ContainerCreate(ctx context.Context, options arvados.CreateOptions) (arvados.Container, error) { + as.appendCall(as.ContainerCreate, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) ContainerUpdate(ctx context.Context, options arvados.UpdateOptions) (arvados.Container, error) { + as.appendCall(as.ContainerUpdate, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) ContainerGet(ctx context.Context, options arvados.GetOptions) (arvados.Container, error) { + as.appendCall(as.ContainerGet, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) ContainerList(ctx context.Context, options arvados.ListOptions) (arvados.ContainerList, error) { + as.appendCall(as.ContainerList, ctx, options) + return arvados.ContainerList{}, as.Error +} +func (as *APIStub) ContainerDelete(ctx context.Context, options arvados.DeleteOptions) (arvados.Container, error) { + as.appendCall(as.ContainerDelete, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) ContainerLock(ctx context.Context, options arvados.GetOptions) (arvados.Container, error) { + as.appendCall(as.ContainerLock, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) ContainerUnlock(ctx context.Context, options arvados.GetOptions) (arvados.Container, error) { + as.appendCall(as.ContainerUnlock, ctx, options) + return arvados.Container{}, as.Error +} +func (as *APIStub) SpecimenCreate(ctx context.Context, options arvados.CreateOptions) (arvados.Specimen, error) { + as.appendCall(as.SpecimenCreate, ctx, options) + return arvados.Specimen{}, as.Error +} +func (as *APIStub) SpecimenUpdate(ctx context.Context, options arvados.UpdateOptions) (arvados.Specimen, error) { + as.appendCall(as.SpecimenUpdate, ctx, options) + return arvados.Specimen{}, as.Error +} +func (as *APIStub) SpecimenGet(ctx context.Context, options arvados.GetOptions) (arvados.Specimen, error) { + as.appendCall(as.SpecimenGet, ctx, options) + return arvados.Specimen{}, as.Error +} +func (as *APIStub) SpecimenList(ctx context.Context, options arvados.ListOptions) (arvados.SpecimenList, error) { + as.appendCall(as.SpecimenList, ctx, options) + return arvados.SpecimenList{}, as.Error +} +func (as *APIStub) SpecimenDelete(ctx context.Context, options arvados.DeleteOptions) (arvados.Specimen, error) { + as.appendCall(as.SpecimenDelete, ctx, options) + return arvados.Specimen{}, as.Error +} +func (as *APIStub) APIClientAuthorizationCurrent(ctx context.Context, options arvados.GetOptions) (arvados.APIClientAuthorization, error) { + as.appendCall(as.APIClientAuthorizationCurrent, ctx, options) + return arvados.APIClientAuthorization{}, as.Error +} + +func (as *APIStub) appendCall(method interface{}, ctx context.Context, options interface{}) { + as.mtx.Lock() + defer as.mtx.Unlock() + as.calls = append(as.calls, APIStubCall{method, ctx, options}) +} + +func (as *APIStub) Calls(method interface{}) []APIStubCall { + as.mtx.Lock() + defer as.mtx.Unlock() + var calls []APIStubCall + for _, call := range as.calls { + if method == nil || call.Method == method { + calls = append(calls, call) + } + } + return calls +} + +type APIStubCall struct { + Method interface{} + Context context.Context + Options interface{} +} -- 2.30.2