diff --git a/.github/workflows/release-nakama.yaml b/.github/workflows/release-nakama.yaml index b65a4e6f2..1e682cc3b 100644 --- a/.github/workflows/release-nakama.yaml +++ b/.github/workflows/release-nakama.yaml @@ -52,6 +52,14 @@ jobs: type=semver,pattern={{version}},value=${{ steps.semver.outputs.tag }} type=semver,pattern={{major}}.{{minor}},value=${{ steps.semver.outputs.tag }} type=sha + - name: Prepare arm64 tags + id: arm64_tags + run: | + TAGS="${{ steps.meta.outputs.tags }}" + TAGS_ARM64="$(echo "$TAGS" | grep -v 'sha-' | sed 's/$/-arm64/g')" + echo "tags<> $GITHUB_OUTPUT + echo "$TAGS_ARM64" >> $GITHUB_OUTPUT + echo "EOF" >> $GITHUB_OUTPUT - name: Build and push uses: docker/build-push-action@v5 with: @@ -70,5 +78,5 @@ jobs: target: nakama-arm platforms: linux/arm64 push: true - tags: ${{ steps.meta.outputs.tags }}-arm64 - labels: ${{ steps.meta.outputs.labels }} \ No newline at end of file + tags: ${{ steps.arm64_tags.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }}-arm64 diff --git a/cardinal/persona_test.go b/cardinal/persona_test.go index 5f1d30c13..33a2de219 100644 --- a/cardinal/persona_test.go +++ b/cardinal/persona_test.go @@ -41,7 +41,7 @@ func TestPersonaTagIsValid(t *testing.T) { } func TestCreatePersonaTransactionAutomaticallyCreated(t *testing.T) { - // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with a engine. + // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with an engine. tf := NewTestFixture(t, nil) world := tf.World tf.StartWorld() @@ -125,7 +125,7 @@ func TestDuplicatePersonaTagsInTickAreOnlyRegisteredOnce(t *testing.T) { } func TestCreatePersonaFailsIfTagIsInvalid(t *testing.T) { - // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with a engine. + // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with an engine. tf := NewTestFixture(t, nil) world := tf.World tf.StartWorld() @@ -140,7 +140,7 @@ func TestCreatePersonaFailsIfTagIsInvalid(t *testing.T) { } func TestSamePersonaWithDifferentCaseCannotBeClaimed(t *testing.T) { - // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with a engine. + // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with an engine. tf := NewTestFixture(t, nil) world := tf.World tf.StartWorld() @@ -154,7 +154,7 @@ func TestSamePersonaWithDifferentCaseCannotBeClaimed(t *testing.T) { } func TestCanAuthorizeAddress(t *testing.T) { - // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with a engine. + // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with an engine. tf := NewTestFixture(t, nil) world := tf.World tf.StartWorld() @@ -192,7 +192,7 @@ func TestCanAuthorizeAddress(t *testing.T) { } func TestAuthorizeAddressFailsOnInvalidAddress(t *testing.T) { - // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with a engine. + // Verify that the cardinal.CreatePersona is automatically cardinal.Created and registered with an engine. tf := NewTestFixture(t, nil) world := tf.World tf.StartWorld() diff --git a/cardinal/receipt/receipt.go b/cardinal/receipt/receipt.go index ceb4b46d8..cbc58b635 100644 --- a/cardinal/receipt/receipt.go +++ b/cardinal/receipt/receipt.go @@ -49,7 +49,7 @@ func (r Receipt) MarshalJSON() ([]byte, error) { }) } -// NewHistory creates a object that can track transaction receipts over a number of ticks. +// NewHistory creates an object that can track transaction receipts over a number of ticks. func NewHistory(currentTick uint64, ticksToStore int) *History { // Add an extra tick for the "current" tick. ticksToStore++ diff --git a/cardinal/world_fixture.go b/cardinal/world_fixture.go index 6368341ab..18deb62e7 100644 --- a/cardinal/world_fixture.go +++ b/cardinal/world_fixture.go @@ -146,7 +146,7 @@ func (t *TestFixture) httpURL(path string) string { return fmt.Sprintf("http://%s/%s", t.BaseURL, path) } -// Post executes a http POST request to this TextFixture's cardinal server. +// Post executes an http POST request to this TextFixture's cardinal server. func (t *TestFixture) Post(path string, payload any) *http.Response { bz, err := json.Marshal(payload) assert.NilError(t, err) @@ -163,7 +163,7 @@ func (t *TestFixture) Post(path string, payload any) *http.Response { return resp } -// Get executes a http GET request to this TestFixture's cardinal server. +// Get executes an http GET request to this TestFixture's cardinal server. func (t *TestFixture) Get(path string) *http.Response { req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, t.httpURL(strings.Trim(path, "/")), nil) diff --git a/docs/cardinal/game/cql.mdx b/docs/cardinal/game/cql.mdx index 2847f829f..b837b0bde 100644 --- a/docs/cardinal/game/cql.mdx +++ b/docs/cardinal/game/cql.mdx @@ -59,7 +59,7 @@ Two functions are provided in the language that accept a variadic amount of comp **Examples:** -- `CONTAINS(armComponent)` is a query for all entities that have a arm component. The entity can have more components than just the arm. +- `CONTAINS(armComponent)` is a query for all entities that have an arm component. The entity can have more components than just the arm. - `CONTAINS(armComponent, legComponent)` is query for all entities that have both an arm component and a leg component. The entity can have more components than the arm and the leg. @@ -92,4 +92,4 @@ You can use parenthesis to specify and change precedence in CQL. - The above is a query for either an entity with only a leg component or an entity that does not have a health component and also does not have an attack component. - Example: `(EXACT(legComponent) | !CONTAINS(healthComponent)) & !CONTAINS(attackComponent)` -- The above is the same query but with precedence changed. Now it is querying an entity with either exactly one leg component or does not have a health component. Additionally that entity must not ever contain a attack component. +- The above is the same query but with precedence changed. Now it is querying an entity with either exactly one leg component or does not have a health component. Additionally that entity must not ever contain an attack component. diff --git a/docs/cardinal/game/world/api-reference.mdx b/docs/cardinal/game/world/api-reference.mdx index 808a44fab..228cb2853 100644 --- a/docs/cardinal/game/world/api-reference.mdx +++ b/docs/cardinal/game/world/api-reference.mdx @@ -186,6 +186,36 @@ func TestGameSystem(t *testing.T) { The WithTickDoneChannel is essential for writing deterministic tests. Always wait for the done signal before making assertions about game state changes. +#### WithMessageExpiration + +The `WithMessageExpiration` option controls how long messages will live past their creation time on the sender before they are considered to be expired and will not be processed. Default is 10 seconds. For longer expiration times you may also need to set a larger hash cache size using the `WithHashCacheSize` option. This setting is ignored if the DisableSignatureVerification option is used. **NOTE**: this means that the real time clock for the sender and receiver must be synchronized + +```go +func WithMessageExpiration(seconds uint) WorldOption +``` + +##### Parameters + +| Parameter | Type | Description | +|-----------|--------|----------------------------------------------------------------| +| seconds | `uint` | How long messages live past their creation time on the sender. | + +#### WithHashCacheSize + +The `WithHashCacheSize` option sets how big (in kilobytes) the cache of hashes used for replay protection is allowed to be. Values less than 512 will be treated as 512 (512K cache size). Default is 1024 (1MB cache size). This setting is ignored if the DisableSignatureVerification option is used + +```go +func WithHashCacheSize(sizeKB uint) WorldOption +``` + +##### Parameters + +| Parameter | Type | Description | +|-----------|--------|----------------------------------------------------------------| +| sizeKB | `uint` | How big the cache for used hashes can be. Min value 512. | + +## RegisterSystems + `RegisterSystems` registers one or more systems to the `World`. Systems are executed in the order of which they were added to the world. ```go diff --git a/docs/cardinal/openapi.json b/docs/cardinal/openapi.json index c70f4acc2..61cf07fc9 100644 --- a/docs/cardinal/openapi.json +++ b/docs/cardinal/openapi.json @@ -421,7 +421,7 @@ "required": [ "body", "namespace", - "nonce", + "timestamp", "personaTag", "signature" ], @@ -435,9 +435,9 @@ "type": "string", "example": "agar-shooter" }, - "nonce": { + "timestamp": { "type": "integer", - "format": "int64" + "format": "unix millisecond timestamp" }, "signature": { "type": "string" @@ -539,7 +539,7 @@ "required": [ "body", "namespace", - "nonce", + "timestamp", "personaTag", "signature" ], @@ -553,9 +553,9 @@ "type": "string", "example": "agar-shooter" }, - "nonce": { + "timestamp": { "type": "integer", - "format": "int64" + "format": "unix millisecond timestamp" }, "signature": { "type": "string" diff --git a/evm/app/export.go b/evm/app/export.go index e6d30d98d..c50f5e8f2 100644 --- a/evm/app/export.go +++ b/evm/app/export.go @@ -79,7 +79,7 @@ func (app *App) ExportAppStateAndValidators( func (app *App) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []string) { applyAllowedAddrs := false - // check if there is a allowed address list + // check if there is an allowed address list if len(jailAllowedAddrs) > 0 { applyAllowedAddrs = true } diff --git a/go.work b/go.work index 5c42a6d77..4c026c71a 100644 --- a/go.work +++ b/go.work @@ -1,4 +1,6 @@ -go 1.22.7 +go 1.23.3 + +toolchain go1.23.4 use ( assert diff --git a/go.work.sum b/go.work.sum index a00c86b4a..2d91a13b4 100644 --- a/go.work.sum +++ b/go.work.sum @@ -2108,8 +2108,6 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/gogo/status v1.1.0 h1:+eIkrewn5q6b30y+g/BJINVVdi2xH7je5MPJ3ZPK3JA= github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM= -github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= -github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= @@ -2136,6 +2134,7 @@ github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= @@ -2181,8 +2180,10 @@ github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-containerregistry v0.13.0 h1:y1C7Z3e149OJbOPDBxLYR8ITPz8dTKqQwjErKVHJC8k= github.com/google/go-containerregistry v0.13.0/go.mod h1:J9FQ+eSS4a1aC2GNZxvNpbWhgp0487v+cgiilB4FqDo= github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4rEjNlfyDHW9dolSY= @@ -2371,6 +2372,7 @@ github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150 h1:vlNjIqmUZ9CMAWsbURY github.com/hydrogen18/memlistener v0.0.0-20141126152155-54553eb933fb/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= github.com/hydrogen18/memlistener v1.0.0 h1:JR7eDj8HD6eXrc5fWLbSUnfcQFL06PYvCc0DKQnWfaU= github.com/hydrogen18/memlistener v1.0.0/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= @@ -3542,7 +3544,6 @@ golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= -golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -3761,7 +3762,6 @@ golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2 h1:IRJeR9r1pYWsHKTRe/IInb7lYvbBVIqOgsX/u0mbOWY= golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE= golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457/go.mod h1:pRgIJT+bRLFKnoM1ldnzKoxTIn14Yxz928LQRYYgIN0= @@ -4049,7 +4049,6 @@ google.golang.org/genproto/googleapis/api v0.0.0-20240513163218-0867130af1f8/go. google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I= google.golang.org/genproto/googleapis/api v0.0.0-20241021214115-324edc3d5d38/go.mod h1:vuAjtvlwkDKF6L1GQ0SokiRLCGFfeBUXWr/aFFkHACc= -google.golang.org/genproto/googleapis/api v0.0.0-20241118233622-e639e219e697/go.mod h1:+D9ySVjN8nY8YCVjc5O7PZDIdZporIDY3KaGfJunh88= google.golang.org/genproto/googleapis/bytestream v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:ylj+BE99M198VPbBh6A8d9n3w8fChvyLK3wwBOjXBFA= google.golang.org/genproto/googleapis/bytestream v0.0.0-20230807174057-1744710a1577/go.mod h1:NjCQG/D8JandXxM57PZbAJL1DCNL6EypA0vPPwfsc7c= google.golang.org/genproto/googleapis/bytestream v0.0.0-20231030173426-d783a09b4405/go.mod h1:GRUCuLdzVqZte8+Dl/D4N25yLzcGqqWaYkeVOwulFqw= @@ -4099,7 +4098,6 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go. google.golang.org/genproto/googleapis/rpc v0.0.0-20240827150818-7e3bb234dfed/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI= -google.golang.org/genproto/googleapis/rpc v0.0.0-20241118233622-e639e219e697/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= google.golang.org/genproto/googleapis/rpc v0.0.0-20241206012308-a4fef0638583/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= google.golang.org/grpc v0.0.0-20170208002647-2a6bf6142e96/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.6.0 h1:vaySXtNtPrLJFCiET8QXtfBrqq16ynklmFGaZwLcd1M= @@ -4126,9 +4124,9 @@ google.golang.org/grpc v1.63.0/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDom google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= google.golang.org/grpc v1.66.0/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y= google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= -google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0 h1:M1YKkFIboKNieVO5DLUEVzQfGwJD30Nv2jfUgzb5UcE= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= @@ -4285,7 +4283,6 @@ mvdan.cc/unparam v0.0.0-20221223090309-7455f1af531d/go.mod h1:IeHQjmn6TOD+e4Z3RF nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= nullprogram.com/x/optparse v1.0.0 h1:xGFgVi5ZaWOnYdac2foDT3vg0ZZC9ErXFV57mr4OHrI= nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= -pkg.world.dev/world-engine/sign v1.1.1/go.mod h1:/8iwRZIKQpVtjU/8s71ueOzIz5230GICF0z1ihu4uq0= rsc.io/binaryregexp v0.2.0 h1:HfqmD5MEmC0zvwBuF187nq9mdnXjXsSivRiXN7SmRkE= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/pdf v0.1.1 h1:k1MczvYDUvJBe93bYd7wrZLLUEcLZAuF824/I4e5Xr4= diff --git a/relay/nakama/Dockerfile b/relay/nakama/Dockerfile index 84ca34fc0..cb1a072fd 100644 --- a/relay/nakama/Dockerfile +++ b/relay/nakama/Dockerfile @@ -1,4 +1,4 @@ -FROM heroiclabs/nakama-pluginbuilder:3.22.0 AS builder +FROM heroiclabs/nakama-pluginbuilder:3.25.0 AS builder ENV GO111MODULE on ENV CGO_ENABLED 1 @@ -12,7 +12,7 @@ RUN go mod download RUN go build --trimpath --buildmode=plugin -o ./plugin.so -FROM heroiclabs/nakama-pluginbuilder:3.22.0-arm AS builder-arm +FROM heroiclabs/nakama-pluginbuilder:3.25.0-arm AS builder-arm ENV GO111MODULE on ENV CGO_ENABLED 1 @@ -26,7 +26,7 @@ RUN go mod download RUN go build --trimpath --buildmode=plugin -o ./plugin.so -FROM heroiclabs/nakama:3.22.0 AS nakama +FROM heroiclabs/nakama:3.25.0 AS nakama RUN apt-get -y update && \ apt-get -y install --no-install-recommends curl && \ @@ -35,7 +35,7 @@ RUN apt-get -y update && \ COPY --from=builder /nakama/plugin/plugin.so /nakama/data/modules/ COPY relay/nakama/local.yml /nakama/data/ -FROM heroiclabs/nakama:3.22.0-arm AS nakama-arm +FROM heroiclabs/nakama:3.25.0-arm AS nakama-arm COPY --from=builder-arm /nakama/plugin/plugin.so /nakama/data/modules/ -COPY relay/nakama/local.yml /nakama/data/ \ No newline at end of file +COPY relay/nakama/local.yml /nakama/data/ diff --git a/relay/nakama/auth/argus_id.go b/relay/nakama/auth/argus_id.go new file mode 100644 index 000000000..500b80182 --- /dev/null +++ b/relay/nakama/auth/argus_id.go @@ -0,0 +1,160 @@ +package auth + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + + "github.com/golang-jwt/jwt" + "github.com/heroiclabs/nakama-common/api" + "github.com/heroiclabs/nakama-common/runtime" + "github.com/rotisserie/eris" + "go.opentelemetry.io/otel" + otelcode "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" + "google.golang.org/grpc/codes" + + "pkg.world.dev/world-engine/relay/nakama/utils" +) + +var ( + ErrInvalidIDForJWT = errors.New("ID doesn't match JWT hash") + ErrInvalidJWTSigningMethod = errors.New("invalid JWT signing algorithm") + ErrInvalidJWT = errors.New("invalid JWT Token") + ErrInvalidJWTClaims = errors.New("invalid JWT claims format") +) + +// The body (claims) of the JWT is decided by Supabase's GoTrue, so we'll have to update this code +// if it were to change in the future. +// src: https://github.com/supabase/auth/blob/master/internal/api/token.go#L24 +type SupabaseClaims struct { + // Supabase uses jwt.RegisteredClaims from golang-jwt/jwt/v5, but it's still based on the same + // RFC (https://datatracker.ietf.org/doc/html/rfc7519) as this version's jwt.StandardClaims. + jwt.StandardClaims + UserMetaData map[string]interface{} `json:"user_metadata"` +} + +func validateAndParseJWT( + ctx context.Context, + jwtHash string, + jwtString string, + jwtSecret string, +) (*SupabaseClaims, error) { + _, span := otel.Tracer("nakama.auth").Start(ctx, "Validating and Parsing JWT") + defer span.End() + + span.AddEvent("Comparing given JWT hash with actual JWT hash") + computedHash := sha256.Sum256([]byte(jwtString)) + computedHashString := hex.EncodeToString(computedHash[:]) + if computedHashString != jwtHash { + span.RecordError(ErrInvalidIDForJWT) + span.SetStatus(otelcode.Error, "Given JWT hash does not match computed hash") + return nil, ErrInvalidIDForJWT + } + + span.AddEvent("Parsing JWT Claims") + token, err := jwt.ParseWithClaims( + jwtString, + &SupabaseClaims{}, + func(token *jwt.Token) (interface{}, error) { + if token.Method != jwt.SigningMethodHS256 { + return nil, eris.Wrapf(ErrInvalidJWTSigningMethod, "Unexpected signing method: %v", token.Header["alg"]) + } + return []byte(jwtSecret), nil + }) + if err != nil { + span.RecordError(err) + span.SetStatus(otelcode.Error, "Failed to parse JWT") + return nil, eris.Wrap(err, "Failed to parse JWT") + } + if !token.Valid { + span.RecordError(ErrInvalidJWT) + span.SetStatus(otelcode.Error, "Invalid JWT token") + return nil, ErrInvalidJWT + } + + claims, ok := token.Claims.(*SupabaseClaims) + // Make sure claims has a subject (the user ID set by Supabase) + if !ok || claims.Subject == "" { + span.RecordError(ErrInvalidJWTClaims) + span.SetStatus(otelcode.Error, "Invalid JWT claims") + return nil, ErrInvalidJWTClaims + } + + span.SetStatus(otelcode.Ok, "Successfully parsed and validated JWT") + return claims, nil +} + +// The AuthenticateCustom request should be called with the sha256 hash of the JWT as the ID and +// include the JWT as a request variable. This is done because the JWTs are often longer than the +// max length of AuthenticateCustom IDs (128 characters). +func authWithArgusID( + ctx context.Context, + logger runtime.Logger, + _ runtime.NakamaModule, + in *api.AuthenticateCustomRequest, +) (*api.AuthenticateCustomRequest, error) { + span := trace.SpanFromContext(ctx) + + jwtHash := in.GetAccount().GetId() + jwt := in.GetAccount().GetVars()["jwt"] + claims, err := validateAndParseJWT(ctx, jwtHash, jwt, GlobalJWTSecret) + if err != nil { + _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.InvalidArgument, "Failed to validate and parse JWT") + return nil, err + } + + if err = claims.Valid(); err != nil { + _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.InvalidArgument, "JWT is not valid") + return nil, err + } + + span.AddEvent("Setting user ID and metadata to request") + // Set account with user id (claims.Subject) and metadata. Nakama account metadata only supports + // string values, so we should also limit the values of user metadata to be only strings. + in.Account.Id = claims.Subject + for key, value := range claims.UserMetaData { + if strValue, ok := value.(string); ok { + in.Account.Vars[key] = strValue + } else { + logger.Warn("Found non-string value in user metadata: %v", value) + } + } + + return in, nil +} + +func linkWithArgusID( + ctx context.Context, + logger runtime.Logger, + _ runtime.NakamaModule, + in *api.AccountCustom, +) (*api.AccountCustom, error) { + span := trace.SpanFromContext(ctx) + + jwtHash := in.GetId() + jwt := in.GetVars()["jwt"] + claims, err := validateAndParseJWT(ctx, jwtHash, jwt, GlobalJWTSecret) + if err != nil { + _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.InvalidArgument, "Failed to parse and verify JWT") + return nil, err + } + + if err = claims.Valid(); err != nil { + _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.InvalidArgument, "JWT is not valid") + return nil, err + } + + span.AddEvent("Setting user ID and metadata to request") + in.Id = claims.Subject + for key, value := range claims.UserMetaData { + if strValue, ok := value.(string); ok { + in.Vars[key] = strValue + } else { + logger.Warn("Found non-string value in user metadata for key: %s", key) + } + } + + return in, nil +} diff --git a/relay/nakama/auth/argus_id_test.go b/relay/nakama/auth/argus_id_test.go new file mode 100644 index 000000000..5da40fbff --- /dev/null +++ b/relay/nakama/auth/argus_id_test.go @@ -0,0 +1,107 @@ +package auth + +import ( + "context" + "crypto/ed25519" + "crypto/sha256" + "encoding/hex" + "testing" + + "github.com/golang-jwt/jwt" + + "pkg.world.dev/world-engine/assert" +) + +const testJWTSecret = "JWTSecretKeyOnlyForTesting" + +func TestValidateAndParseJWTHappyPath(t *testing.T) { + claims := SupabaseClaims{ + StandardClaims: jwt.StandardClaims{ + Subject: "test-user-id", + }, + UserMetaData: map[string]interface{}{}, + } + + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + jwtString, err := token.SignedString([]byte(testJWTSecret)) + assert.Nil(t, err) + + hash := sha256.Sum256([]byte(jwtString)) + jwtHash := hex.EncodeToString(hash[:]) + + _, err = validateAndParseJWT(context.Background(), jwtHash, jwtString, testJWTSecret) + assert.Nil(t, err) +} + +func TestValidateAndParseJWTWithWrongID(t *testing.T) { + claims := SupabaseClaims{ + StandardClaims: jwt.StandardClaims{ + Subject: "test-user-id", + }, + UserMetaData: map[string]interface{}{}, + } + + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + jwtString, err := token.SignedString([]byte(testJWTSecret)) + assert.Nil(t, err) + + wrongHash := "invalidhashvalue" + + _, err = validateAndParseJWT(context.Background(), wrongHash, jwtString, testJWTSecret) + assert.ErrorContains(t, err, ErrInvalidIDForJWT.Error()) +} + +func TestValidateAndParseJWTWithWrongSecret(t *testing.T) { + claims := SupabaseClaims{ + StandardClaims: jwt.StandardClaims{ + Subject: "test-user-id", + }, + UserMetaData: map[string]interface{}{}, + } + + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + jwtString, err := token.SignedString([]byte("ThisIsNotTheRightSecret")) + assert.Nil(t, err) + + hash := sha256.Sum256([]byte(jwtString)) + jwtHash := hex.EncodeToString(hash[:]) + + _, err = validateAndParseJWT(context.Background(), jwtHash, jwtString, testJWTSecret) + assert.ErrorContains(t, err, jwt.ErrSignatureInvalid.Error()) +} + +func TestValidateAndParseJWTWithWrongSigningMethod(t *testing.T) { + claims := SupabaseClaims{ + StandardClaims: jwt.StandardClaims{ + Subject: "test-user-id", + }, + UserMetaData: map[string]interface{}{}, + } + + _, privateKey, _ := ed25519.GenerateKey(nil) + token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims) + jwtString, err := token.SignedString(privateKey) + assert.Nil(t, err) + + hash := sha256.Sum256([]byte(jwtString)) + jwtHash := hex.EncodeToString(hash[:]) + + _, err = validateAndParseJWT(context.Background(), jwtHash, jwtString, testJWTSecret) + assert.ErrorContains(t, err, ErrInvalidJWTSigningMethod.Error()) +} + +func TestValidateAndParseJWTWithInvalidClaims(t *testing.T) { + // Subject should be set + claims := SupabaseClaims{ + StandardClaims: jwt.StandardClaims{}, + } + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + jwtString, err := token.SignedString([]byte(testJWTSecret)) + assert.Nil(t, err) + + hash := sha256.Sum256([]byte(jwtString)) + jwtHash := hex.EncodeToString(hash[:]) + + _, err = validateAndParseJWT(context.Background(), jwtHash, jwtString, testJWTSecret) + assert.ErrorContains(t, err, ErrInvalidJWTClaims.Error()) +} diff --git a/relay/nakama/auth/custom.go b/relay/nakama/auth/custom.go index 2611d4e6c..fe8e91bc2 100644 --- a/relay/nakama/auth/custom.go +++ b/relay/nakama/auth/custom.go @@ -4,24 +4,51 @@ import ( "context" "database/sql" "errors" + "os" "github.com/heroiclabs/nakama-common/api" "github.com/heroiclabs/nakama-common/runtime" "github.com/rotisserie/eris" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + otelcode "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) const ( signInWithEthereumType = "siwe" + signInWithArgusIDType = "argus" + envJWTSecret = "JWT_SECRET" ) var ( ErrBadCustomAuthType = errors.New("bad custom auth type") + GlobalJWTSecret string ) -func InitCustomAuthentication(initializer runtime.Initializer) error { +func checkJWTSecret(logger runtime.Logger) { + if GlobalJWTSecret == "" { + GlobalJWTSecret = os.Getenv(envJWTSecret) + } + if GlobalJWTSecret == "" { + logger.Warn("JWT secret isn't set. You won't be able to use Argus ID custom link") + } +} + +// Now we can only use symmetric JWTs, which means that the custom Argus ID authentication can only +// be used for our (Argus) projects because we can't share the JWT secret. Instead of failing +// during initialization if the JWT secret isn't set, we'll log a warning message and return a +// ErrBadCustomAuthType if a client tries to use Argus ID custom authentication. +// +// When Supabase rolls out asymmetric JWTs, the JWT secret can be shared because it is essentialy a +// public key. If the JWT_SECRET variable isn't set, we can consider fetching a valid public key +// and set it as the value of JWT_SECRET. This way, Argus ID authentication will always be enabled +// (assuming the fetch didn't fail), and we don't have to return an error. +func InitCustomAuthentication(logger runtime.Logger, initializer runtime.Initializer) error { if err := initializer.RegisterBeforeAuthenticateCustom(handleCustomAuthentication); err != nil { return eris.Wrap(err, "failed to init custom authentication") } + checkJWTSecret(logger) return nil } @@ -32,17 +59,46 @@ func handleCustomAuthentication( nk runtime.NakamaModule, in *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error) { authType := in.GetAccount().GetVars()["type"] + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "AuthenticateCustom", + trace.WithAttributes( + attribute.String("type", authType), + )) + defer span.End() // In the future, other authentication methods can be added here (e.g. Twitter) if authType == signInWithEthereumType { - return authWithSIWE(ctx, logger, nk, in) + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "SIWE Custom Auth") + defer span.End() + in, err := authWithSIWE(ctx, logger, nk, in) + if err != nil { + span.RecordError(err) + span.SetStatus(otelcode.Error, "Failed to authenticate with SIWE") + return nil, err + } + span.SetStatus(otelcode.Ok, "Successfully authenticated with SIWE") + return in, nil + } + if authType == signInWithArgusIDType && GlobalJWTSecret != "" { + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "Argus ID Custom Auth") + defer span.End() + in, err := authWithArgusID(ctx, logger, nk, in) + if err != nil { + span.RecordError(err) + span.SetStatus(otelcode.Error, "Failed to authenticate with Argus ID") + return nil, err + } + span.SetStatus(otelcode.Ok, "Successfully authenticated with Argus ID") + return in, nil } + span.RecordError(ErrBadCustomAuthType) + span.SetStatus(otelcode.Error, "Bad custom auth type") return nil, ErrBadCustomAuthType } -func InitCustomLink(initializer runtime.Initializer) error { +func InitCustomLink(logger runtime.Logger, initializer runtime.Initializer) error { if err := initializer.RegisterBeforeLinkCustom(handleCustomLink); err != nil { return eris.Wrap(err, "failed to init custom link") } + checkJWTSecret(logger) return nil } @@ -53,9 +109,37 @@ func handleCustomLink( nk runtime.NakamaModule, in *api.AccountCustom) (*api.AccountCustom, error) { authType := in.GetVars()["type"] + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "LinkCustom", + trace.WithAttributes( + attribute.String("type", authType), + )) + defer span.End() // In the future, other authentication methods can be added here (e.g. Twitter) if authType == signInWithEthereumType { - return linkWithSIWE(ctx, logger, nk, in) + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "SIWE Custom Link") + defer span.End() + in, err := linkWithSIWE(ctx, logger, nk, in) + if err != nil { + span.RecordError(err) + span.SetStatus(otelcode.Error, "Failed to link with SIWE") + return nil, err + } + span.SetStatus(otelcode.Ok, "Successfully linked with SIWE") + return in, nil + } + if authType == signInWithArgusIDType && GlobalJWTSecret != "" { + ctx, span := otel.Tracer("nakama.auth").Start(ctx, "Argus ID Custom Link") + defer span.End() + in, err := linkWithArgusID(ctx, logger, nk, in) + if err != nil { + span.RecordError(err) + span.SetStatus(otelcode.Error, "Failed to link with Argus ID") + return nil, err + } + span.SetStatus(otelcode.Ok, "Successfully linked with Argus ID") + return in, nil } + span.RecordError(ErrBadCustomAuthType) + span.SetStatus(otelcode.Error, "Bad custom auth type") return nil, ErrBadCustomAuthType } diff --git a/relay/nakama/auth/siwe.go b/relay/nakama/auth/siwe.go index c7ec6c33e..1a5c25224 100644 --- a/relay/nakama/auth/siwe.go +++ b/relay/nakama/auth/siwe.go @@ -8,6 +8,7 @@ import ( "github.com/heroiclabs/nakama-common/api" "github.com/heroiclabs/nakama-common/runtime" "github.com/rotisserie/eris" + "go.opentelemetry.io/otel/trace" "google.golang.org/grpc/codes" "pkg.world.dev/world-engine/relay/nakama/siwe" @@ -23,7 +24,7 @@ func validateSIWE(signer, message, signature string) (isValidationRequest bool, errs = append(errs, eris.Wrap(siwe.ErrMissingSignature, "signature field must be set")) } if signature != "" && message == "" { - errs = append(errs, eris.Wrap(siwe.ErrMissingMessage, "signature field must be set")) + errs = append(errs, eris.Wrap(siwe.ErrMissingMessage, "message field must be set")) } if len(errs) > 0 { return false, errors.Join(errs...) @@ -40,6 +41,8 @@ func processSIWE( nk runtime.NakamaModule, signerAddress, signature, message string, ) error { + span := trace.SpanFromContext(ctx) + span.AddEvent("Validating SIWE request") isValidationRequest, err := validateSIWE(signerAddress, message, signature) if err != nil { _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.InvalidArgument, "invalid vars") @@ -47,6 +50,7 @@ func processSIWE( } if !isValidationRequest { + span.AddEvent("Generating SIWE message to sign") // The signature and message is empty. Generate a new SIWE message for the user. resp, err := siwe.GenerateNewSIWEMessage(signerAddress) if err != nil { @@ -54,6 +58,7 @@ func processSIWE( return err } + span.AddEvent("Marshalling SIWE message into JSON") bz, err := json.Marshal(resp) if err != nil { _, err = utils.LogErrorWithMessageAndCode(logger, err, codes.FailedPrecondition, "") @@ -64,6 +69,7 @@ func processSIWE( return runtime.NewError(string(bz), int(codes.Unauthenticated)) } + span.AddEvent("Validating SIWE signature") // The user has provided a signature and a message. Attempt to authenticate the user. if err := siwe.ValidateSignature(ctx, nk, signerAddress, message, signature); err != nil { _, err = utils.LogErrorWithMessageAndCode( diff --git a/relay/nakama/auth/custom_test.go b/relay/nakama/auth/siwe_test.go similarity index 100% rename from relay/nakama/auth/custom_test.go rename to relay/nakama/auth/siwe_test.go diff --git a/relay/nakama/go.mod b/relay/nakama/go.mod index 1634c9e71..d334a9c1e 100644 --- a/relay/nakama/go.mod +++ b/relay/nakama/go.mod @@ -1,17 +1,18 @@ module pkg.world.dev/world-engine/relay/nakama -go 1.22.7 +go 1.23.3 -toolchain go1.23.3 +toolchain go1.23.4 //replace pkg.world.dev/world-engine/sign => ../../sign require ( cloud.google.com/go/kms v1.15.7 github.com/ethereum/go-ethereum v1.14.12 + github.com/golang-jwt/jwt v3.2.2+incompatible github.com/googleapis/gax-go/v2 v2.12.3 github.com/gorilla/websocket v1.5.3 - github.com/heroiclabs/nakama-common v1.32.0 + github.com/heroiclabs/nakama-common v1.35.0 github.com/rotisserie/eris v0.5.4 github.com/spruceid/siwe-go v0.2.1 github.com/stretchr/testify v1.10.0 @@ -20,7 +21,7 @@ require ( go.opentelemetry.io/otel/sdk v1.32.0 go.opentelemetry.io/otel/trace v1.32.0 google.golang.org/api v0.171.0 - google.golang.org/grpc v1.68.1 + google.golang.org/grpc v1.68.0 google.golang.org/protobuf v1.35.2 pkg.world.dev/world-engine/assert v1.0.0 pkg.world.dev/world-engine/sign v1.1.0 @@ -36,11 +37,11 @@ require ( github.com/relvacode/iso8601 v1.1.1-0.20210511065120-b30b151cc433 // indirect go.opencensus.io v0.24.0 // indirect golang.org/x/oauth2 v0.24.0 // indirect - golang.org/x/sync v0.10.0 // indirect - golang.org/x/text v0.21.0 // indirect + golang.org/x/sync v0.9.0 // indirect + golang.org/x/text v0.20.0 // indirect golang.org/x/time v0.5.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20241118233622-e639e219e697 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20241118233622-e639e219e697 // indirect ) require ( @@ -63,10 +64,10 @@ require ( go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.32.0 // indirect go.opentelemetry.io/otel/metric v1.32.0 // indirect - go.opentelemetry.io/proto/otlp v1.4.0 // indirect - golang.org/x/crypto v0.30.0 // indirect - golang.org/x/net v0.32.0 // indirect - golang.org/x/sys v0.28.0 // indirect + go.opentelemetry.io/proto/otlp v1.3.1 // indirect + golang.org/x/crypto v0.29.0 // indirect + golang.org/x/net v0.30.0 // indirect + golang.org/x/sys v0.27.0 // indirect google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de // indirect gopkg.in/yaml.v3 v3.0.1 // indirect gotest.tools/v3 v3.5.1 // indirect diff --git a/relay/nakama/go.sum b/relay/nakama/go.sum index 433aef7cc..6cb3e06f8 100644 --- a/relay/nakama/go.sum +++ b/relay/nakama/go.sum @@ -36,6 +36,8 @@ github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= @@ -73,8 +75,8 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0 h1:TmHmbvxPmaegwhDubVz0lICL0J5Ka2vwTzhoePEXsGE= github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0/go.mod h1:qztMSjm835F2bXf+5HKAPIS5qsmQDqZna/PgVt4rWtI= -github.com/heroiclabs/nakama-common v1.32.0 h1:aCWyYf9mQzifeVu3bXBiRRL9Z/dGBgwY/rgUWoYCnQM= -github.com/heroiclabs/nakama-common v1.32.0/go.mod h1:lPG64MVCs0/tEkh311Cd6oHX9NLx2vAPx7WW7QCJHQ0= +github.com/heroiclabs/nakama-common v1.35.0 h1:gO3J2v2E12sZ2uL258lt5YF6yNO1tiPtvL7ZwV8t/n0= +github.com/heroiclabs/nakama-common v1.35.0/go.mod h1:E4kw2QpsINoXXJS7aOjen1dycPkoo9bD9pYPAjmA8rc= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -123,14 +125,14 @@ go.opentelemetry.io/otel/sdk v1.32.0 h1:RNxepc9vK59A8XsgZQouW8ue8Gkb4jpWtJm9ge5l go.opentelemetry.io/otel/sdk v1.32.0/go.mod h1:LqgegDBjKMmb2GC6/PrTnteJG39I8/vJCAP9LlJXEjU= go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= -go.opentelemetry.io/proto/otlp v1.4.0 h1:TA9WRvW6zMwP+Ssb6fLoUIuirti1gGbP28GcKG1jgeg= -go.opentelemetry.io/proto/otlp v1.4.0/go.mod h1:PPBWZIP98o2ElSqI35IHfu7hIhSwvc5N38Jw8pXuGFY= +go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= +go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY= -golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -141,26 +143,26 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI= -golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs= +golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4= +golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE= golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= -golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= -golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= -golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -178,17 +180,17 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de h1:F6qOa9AZTYJXOUEr4jDysRDLrm4PHePlge4v4TGAlxY= google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:VUhTRKeHn9wwcdrk73nvdC9gF178Tzhmt/qyaFcPLSo= -google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 h1:CkkIfIt50+lT6NHAVoRYEyAvQGFM7xEwXUUywFvEb3Q= -google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576/go.mod h1:1R3kvZ1dtP3+4p4d3G8uJ8rFk/fWlScl38vanWACI08= -google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 h1:8ZmaLZE4XWrtU3MyClkYqqtl6Oegr3235h7jxsDyqCY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= +google.golang.org/genproto/googleapis/api v0.0.0-20241118233622-e639e219e697 h1:pgr/4QbFyktUv9CtQ/Fq4gzEE6/Xs7iCXbktaGzLHbQ= +google.golang.org/genproto/googleapis/api v0.0.0-20241118233622-e639e219e697/go.mod h1:+D9ySVjN8nY8YCVjc5O7PZDIdZporIDY3KaGfJunh88= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241118233622-e639e219e697 h1:LWZqQOEjDyONlF1H6afSWpAL/znlREo2tHfLoe+8LMA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241118233622-e639e219e697/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.68.1 h1:oI5oTa11+ng8r8XMMN7jAOmWfPZWbYpCFaMUTACxkM0= -google.golang.org/grpc v1.68.1/go.mod h1:+q1XYFJjShcqn0QZHvCyeR4CXPA+llXIeUIfIe00waw= +google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0= +google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/relay/nakama/main.go b/relay/nakama/main.go index ee62d7d51..7efab9529 100644 --- a/relay/nakama/main.go +++ b/relay/nakama/main.go @@ -126,12 +126,12 @@ func InitModule( return eris.Wrap(err, "failed to init save file query endpoint") } - if err := auth.InitCustomAuthentication(initializer); err != nil { - return eris.Wrap(err, "failed to init ethereum authentication") + if err := auth.InitCustomAuthentication(logger, initializer); err != nil { + return eris.Wrap(err, "failed to init custom authentication") } - if err := auth.InitCustomLink(initializer); err != nil { - return eris.Wrap(err, "failed to init ethereum link") + if err := auth.InitCustomLink(logger, initializer); err != nil { + return eris.Wrap(err, "failed to init custom link") } return nil } diff --git a/relay/nakama/mocks/mock_Config.go b/relay/nakama/mocks/mock_Config.go new file mode 100644 index 000000000..96d820c2c --- /dev/null +++ b/relay/nakama/mocks/mock_Config.go @@ -0,0 +1,501 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import ( + runtime "github.com/heroiclabs/nakama-common/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockConfig is an autogenerated mock type for the Config type +type MockConfig struct { + mock.Mock +} + +type MockConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockConfig) EXPECT() *MockConfig_Expecter { + return &MockConfig_Expecter{mock: &_m.Mock} +} + +// GetGoogleAuth provides a mock function with no fields +func (_m *MockConfig) GetGoogleAuth() runtime.GoogleAuthConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetGoogleAuth") + } + + var r0 runtime.GoogleAuthConfig + if rf, ok := ret.Get(0).(func() runtime.GoogleAuthConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.GoogleAuthConfig) + } + } + + return r0 +} + +// MockConfig_GetGoogleAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGoogleAuth' +type MockConfig_GetGoogleAuth_Call struct { + *mock.Call +} + +// GetGoogleAuth is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetGoogleAuth() *MockConfig_GetGoogleAuth_Call { + return &MockConfig_GetGoogleAuth_Call{Call: _e.mock.On("GetGoogleAuth")} +} + +func (_c *MockConfig_GetGoogleAuth_Call) Run(run func()) *MockConfig_GetGoogleAuth_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetGoogleAuth_Call) Return(_a0 runtime.GoogleAuthConfig) *MockConfig_GetGoogleAuth_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetGoogleAuth_Call) RunAndReturn(run func() runtime.GoogleAuthConfig) *MockConfig_GetGoogleAuth_Call { + _c.Call.Return(run) + return _c +} + +// GetIAP provides a mock function with no fields +func (_m *MockConfig) GetIAP() runtime.IAPConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetIAP") + } + + var r0 runtime.IAPConfig + if rf, ok := ret.Get(0).(func() runtime.IAPConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.IAPConfig) + } + } + + return r0 +} + +// MockConfig_GetIAP_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIAP' +type MockConfig_GetIAP_Call struct { + *mock.Call +} + +// GetIAP is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetIAP() *MockConfig_GetIAP_Call { + return &MockConfig_GetIAP_Call{Call: _e.mock.On("GetIAP")} +} + +func (_c *MockConfig_GetIAP_Call) Run(run func()) *MockConfig_GetIAP_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetIAP_Call) Return(_a0 runtime.IAPConfig) *MockConfig_GetIAP_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetIAP_Call) RunAndReturn(run func() runtime.IAPConfig) *MockConfig_GetIAP_Call { + _c.Call.Return(run) + return _c +} + +// GetLogger provides a mock function with no fields +func (_m *MockConfig) GetLogger() runtime.LoggerConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetLogger") + } + + var r0 runtime.LoggerConfig + if rf, ok := ret.Get(0).(func() runtime.LoggerConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.LoggerConfig) + } + } + + return r0 +} + +// MockConfig_GetLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogger' +type MockConfig_GetLogger_Call struct { + *mock.Call +} + +// GetLogger is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetLogger() *MockConfig_GetLogger_Call { + return &MockConfig_GetLogger_Call{Call: _e.mock.On("GetLogger")} +} + +func (_c *MockConfig_GetLogger_Call) Run(run func()) *MockConfig_GetLogger_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetLogger_Call) Return(_a0 runtime.LoggerConfig) *MockConfig_GetLogger_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetLogger_Call) RunAndReturn(run func() runtime.LoggerConfig) *MockConfig_GetLogger_Call { + _c.Call.Return(run) + return _c +} + +// GetName provides a mock function with no fields +func (_m *MockConfig) GetName() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetName") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockConfig_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type MockConfig_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetName() *MockConfig_GetName_Call { + return &MockConfig_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *MockConfig_GetName_Call) Run(run func()) *MockConfig_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetName_Call) Return(_a0 string) *MockConfig_GetName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetName_Call) RunAndReturn(run func() string) *MockConfig_GetName_Call { + _c.Call.Return(run) + return _c +} + +// GetRuntime provides a mock function with no fields +func (_m *MockConfig) GetRuntime() runtime.RuntimeConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRuntime") + } + + var r0 runtime.RuntimeConfig + if rf, ok := ret.Get(0).(func() runtime.RuntimeConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.RuntimeConfig) + } + } + + return r0 +} + +// MockConfig_GetRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRuntime' +type MockConfig_GetRuntime_Call struct { + *mock.Call +} + +// GetRuntime is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetRuntime() *MockConfig_GetRuntime_Call { + return &MockConfig_GetRuntime_Call{Call: _e.mock.On("GetRuntime")} +} + +func (_c *MockConfig_GetRuntime_Call) Run(run func()) *MockConfig_GetRuntime_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetRuntime_Call) Return(_a0 runtime.RuntimeConfig) *MockConfig_GetRuntime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetRuntime_Call) RunAndReturn(run func() runtime.RuntimeConfig) *MockConfig_GetRuntime_Call { + _c.Call.Return(run) + return _c +} + +// GetSatori provides a mock function with no fields +func (_m *MockConfig) GetSatori() runtime.SatoriConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSatori") + } + + var r0 runtime.SatoriConfig + if rf, ok := ret.Get(0).(func() runtime.SatoriConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SatoriConfig) + } + } + + return r0 +} + +// MockConfig_GetSatori_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSatori' +type MockConfig_GetSatori_Call struct { + *mock.Call +} + +// GetSatori is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetSatori() *MockConfig_GetSatori_Call { + return &MockConfig_GetSatori_Call{Call: _e.mock.On("GetSatori")} +} + +func (_c *MockConfig_GetSatori_Call) Run(run func()) *MockConfig_GetSatori_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetSatori_Call) Return(_a0 runtime.SatoriConfig) *MockConfig_GetSatori_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetSatori_Call) RunAndReturn(run func() runtime.SatoriConfig) *MockConfig_GetSatori_Call { + _c.Call.Return(run) + return _c +} + +// GetSession provides a mock function with no fields +func (_m *MockConfig) GetSession() runtime.SessionConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSession") + } + + var r0 runtime.SessionConfig + if rf, ok := ret.Get(0).(func() runtime.SessionConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SessionConfig) + } + } + + return r0 +} + +// MockConfig_GetSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSession' +type MockConfig_GetSession_Call struct { + *mock.Call +} + +// GetSession is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetSession() *MockConfig_GetSession_Call { + return &MockConfig_GetSession_Call{Call: _e.mock.On("GetSession")} +} + +func (_c *MockConfig_GetSession_Call) Run(run func()) *MockConfig_GetSession_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetSession_Call) Return(_a0 runtime.SessionConfig) *MockConfig_GetSession_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetSession_Call) RunAndReturn(run func() runtime.SessionConfig) *MockConfig_GetSession_Call { + _c.Call.Return(run) + return _c +} + +// GetShutdownGraceSec provides a mock function with no fields +func (_m *MockConfig) GetShutdownGraceSec() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetShutdownGraceSec") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// MockConfig_GetShutdownGraceSec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShutdownGraceSec' +type MockConfig_GetShutdownGraceSec_Call struct { + *mock.Call +} + +// GetShutdownGraceSec is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetShutdownGraceSec() *MockConfig_GetShutdownGraceSec_Call { + return &MockConfig_GetShutdownGraceSec_Call{Call: _e.mock.On("GetShutdownGraceSec")} +} + +func (_c *MockConfig_GetShutdownGraceSec_Call) Run(run func()) *MockConfig_GetShutdownGraceSec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetShutdownGraceSec_Call) Return(_a0 int) *MockConfig_GetShutdownGraceSec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetShutdownGraceSec_Call) RunAndReturn(run func() int) *MockConfig_GetShutdownGraceSec_Call { + _c.Call.Return(run) + return _c +} + +// GetSocial provides a mock function with no fields +func (_m *MockConfig) GetSocial() runtime.SocialConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSocial") + } + + var r0 runtime.SocialConfig + if rf, ok := ret.Get(0).(func() runtime.SocialConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocialConfig) + } + } + + return r0 +} + +// MockConfig_GetSocial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSocial' +type MockConfig_GetSocial_Call struct { + *mock.Call +} + +// GetSocial is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetSocial() *MockConfig_GetSocial_Call { + return &MockConfig_GetSocial_Call{Call: _e.mock.On("GetSocial")} +} + +func (_c *MockConfig_GetSocial_Call) Run(run func()) *MockConfig_GetSocial_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetSocial_Call) Return(_a0 runtime.SocialConfig) *MockConfig_GetSocial_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetSocial_Call) RunAndReturn(run func() runtime.SocialConfig) *MockConfig_GetSocial_Call { + _c.Call.Return(run) + return _c +} + +// GetSocket provides a mock function with no fields +func (_m *MockConfig) GetSocket() runtime.SocketConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSocket") + } + + var r0 runtime.SocketConfig + if rf, ok := ret.Get(0).(func() runtime.SocketConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocketConfig) + } + } + + return r0 +} + +// MockConfig_GetSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSocket' +type MockConfig_GetSocket_Call struct { + *mock.Call +} + +// GetSocket is a helper method to define mock.On call +func (_e *MockConfig_Expecter) GetSocket() *MockConfig_GetSocket_Call { + return &MockConfig_GetSocket_Call{Call: _e.mock.On("GetSocket")} +} + +func (_c *MockConfig_GetSocket_Call) Run(run func()) *MockConfig_GetSocket_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConfig_GetSocket_Call) Return(_a0 runtime.SocketConfig) *MockConfig_GetSocket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockConfig_GetSocket_Call) RunAndReturn(run func() runtime.SocketConfig) *MockConfig_GetSocket_Call { + _c.Call.Return(run) + return _c +} + +// NewMockConfig creates a new instance of MockConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockConfig { + mock := &MockConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_FleetManager.go b/relay/nakama/mocks/mock_FleetManager.go index 5528fb86b..360422aaa 100644 --- a/relay/nakama/mocks/mock_FleetManager.go +++ b/relay/nakama/mocks/mock_FleetManager.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -14,10 +14,22 @@ type MockFleetManager struct { mock.Mock } +type MockFleetManager_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFleetManager) EXPECT() *MockFleetManager_Expecter { + return &MockFleetManager_Expecter{mock: &_m.Mock} +} + // Create provides a mock function with given fields: ctx, maxPlayers, userIds, latencies, metadata, callback func (_m *MockFleetManager) Create(ctx context.Context, maxPlayers int, userIds []string, latencies []runtime.FleetUserLatencies, metadata map[string]interface{}, callback runtime.FmCreateCallbackFn) error { ret := _m.Called(ctx, maxPlayers, userIds, latencies, metadata, callback) + if len(ret) == 0 { + panic("no return value specified for Create") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, int, []string, []runtime.FleetUserLatencies, map[string]interface{}, runtime.FmCreateCallbackFn) error); ok { r0 = rf(ctx, maxPlayers, userIds, latencies, metadata, callback) @@ -28,10 +40,47 @@ func (_m *MockFleetManager) Create(ctx context.Context, maxPlayers int, userIds return r0 } +// MockFleetManager_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockFleetManager_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - maxPlayers int +// - userIds []string +// - latencies []runtime.FleetUserLatencies +// - metadata map[string]interface{} +// - callback runtime.FmCreateCallbackFn +func (_e *MockFleetManager_Expecter) Create(ctx interface{}, maxPlayers interface{}, userIds interface{}, latencies interface{}, metadata interface{}, callback interface{}) *MockFleetManager_Create_Call { + return &MockFleetManager_Create_Call{Call: _e.mock.On("Create", ctx, maxPlayers, userIds, latencies, metadata, callback)} +} + +func (_c *MockFleetManager_Create_Call) Run(run func(ctx context.Context, maxPlayers int, userIds []string, latencies []runtime.FleetUserLatencies, metadata map[string]interface{}, callback runtime.FmCreateCallbackFn)) *MockFleetManager_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].([]string), args[3].([]runtime.FleetUserLatencies), args[4].(map[string]interface{}), args[5].(runtime.FmCreateCallbackFn)) + }) + return _c +} + +func (_c *MockFleetManager_Create_Call) Return(err error) *MockFleetManager_Create_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockFleetManager_Create_Call) RunAndReturn(run func(context.Context, int, []string, []runtime.FleetUserLatencies, map[string]interface{}, runtime.FmCreateCallbackFn) error) *MockFleetManager_Create_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, id func (_m *MockFleetManager) Get(ctx context.Context, id string) (*runtime.InstanceInfo, error) { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for Get") + } + var r0 *runtime.InstanceInfo var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*runtime.InstanceInfo, error)); ok { @@ -54,10 +103,43 @@ func (_m *MockFleetManager) Get(ctx context.Context, id string) (*runtime.Instan return r0, r1 } +// MockFleetManager_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockFleetManager_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockFleetManager_Expecter) Get(ctx interface{}, id interface{}) *MockFleetManager_Get_Call { + return &MockFleetManager_Get_Call{Call: _e.mock.On("Get", ctx, id)} +} + +func (_c *MockFleetManager_Get_Call) Run(run func(ctx context.Context, id string)) *MockFleetManager_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockFleetManager_Get_Call) Return(instance *runtime.InstanceInfo, err error) *MockFleetManager_Get_Call { + _c.Call.Return(instance, err) + return _c +} + +func (_c *MockFleetManager_Get_Call) RunAndReturn(run func(context.Context, string) (*runtime.InstanceInfo, error)) *MockFleetManager_Get_Call { + _c.Call.Return(run) + return _c +} + // Join provides a mock function with given fields: ctx, id, userIds, metadata func (_m *MockFleetManager) Join(ctx context.Context, id string, userIds []string, metadata map[string]string) (*runtime.JoinInfo, error) { ret := _m.Called(ctx, id, userIds, metadata) + if len(ret) == 0 { + panic("no return value specified for Join") + } + var r0 *runtime.JoinInfo var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, []string, map[string]string) (*runtime.JoinInfo, error)); ok { @@ -80,10 +162,45 @@ func (_m *MockFleetManager) Join(ctx context.Context, id string, userIds []strin return r0, r1 } +// MockFleetManager_Join_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Join' +type MockFleetManager_Join_Call struct { + *mock.Call +} + +// Join is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userIds []string +// - metadata map[string]string +func (_e *MockFleetManager_Expecter) Join(ctx interface{}, id interface{}, userIds interface{}, metadata interface{}) *MockFleetManager_Join_Call { + return &MockFleetManager_Join_Call{Call: _e.mock.On("Join", ctx, id, userIds, metadata)} +} + +func (_c *MockFleetManager_Join_Call) Run(run func(ctx context.Context, id string, userIds []string, metadata map[string]string)) *MockFleetManager_Join_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(map[string]string)) + }) + return _c +} + +func (_c *MockFleetManager_Join_Call) Return(joinInfo *runtime.JoinInfo, err error) *MockFleetManager_Join_Call { + _c.Call.Return(joinInfo, err) + return _c +} + +func (_c *MockFleetManager_Join_Call) RunAndReturn(run func(context.Context, string, []string, map[string]string) (*runtime.JoinInfo, error)) *MockFleetManager_Join_Call { + _c.Call.Return(run) + return _c +} + // List provides a mock function with given fields: ctx, query, limit, previousCursor func (_m *MockFleetManager) List(ctx context.Context, query string, limit int, previousCursor string) ([]*runtime.InstanceInfo, string, error) { ret := _m.Called(ctx, query, limit, previousCursor) + if len(ret) == 0 { + panic("no return value specified for List") + } + var r0 []*runtime.InstanceInfo var r1 string var r2 error @@ -113,13 +230,43 @@ func (_m *MockFleetManager) List(ctx context.Context, query string, limit int, p return r0, r1, r2 } -type mockConstructorTestingTNewMockFleetManager interface { - mock.TestingT - Cleanup(func()) +// MockFleetManager_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type MockFleetManager_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - limit int +// - previousCursor string +func (_e *MockFleetManager_Expecter) List(ctx interface{}, query interface{}, limit interface{}, previousCursor interface{}) *MockFleetManager_List_Call { + return &MockFleetManager_List_Call{Call: _e.mock.On("List", ctx, query, limit, previousCursor)} +} + +func (_c *MockFleetManager_List_Call) Run(run func(ctx context.Context, query string, limit int, previousCursor string)) *MockFleetManager_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockFleetManager_List_Call) Return(list []*runtime.InstanceInfo, nextCursor string, err error) *MockFleetManager_List_Call { + _c.Call.Return(list, nextCursor, err) + return _c +} + +func (_c *MockFleetManager_List_Call) RunAndReturn(run func(context.Context, string, int, string) ([]*runtime.InstanceInfo, string, error)) *MockFleetManager_List_Call { + _c.Call.Return(run) + return _c } // NewMockFleetManager creates a new instance of MockFleetManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockFleetManager(t mockConstructorTestingTNewMockFleetManager) *MockFleetManager { +// The first argument is typically a *testing.T value. +func NewMockFleetManager(t interface { + mock.TestingT + Cleanup(func()) +}) *MockFleetManager { mock := &MockFleetManager{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_FleetManagerInitializer.go b/relay/nakama/mocks/mock_FleetManagerInitializer.go index b170f53bf..3b5f4c94c 100644 --- a/relay/nakama/mocks/mock_FleetManagerInitializer.go +++ b/relay/nakama/mocks/mock_FleetManagerInitializer.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -14,10 +14,22 @@ type MockFleetManagerInitializer struct { mock.Mock } +type MockFleetManagerInitializer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFleetManagerInitializer) EXPECT() *MockFleetManagerInitializer_Expecter { + return &MockFleetManagerInitializer_Expecter{mock: &_m.Mock} +} + // Create provides a mock function with given fields: ctx, maxPlayers, userIds, latencies, metadata, callback func (_m *MockFleetManagerInitializer) Create(ctx context.Context, maxPlayers int, userIds []string, latencies []runtime.FleetUserLatencies, metadata map[string]interface{}, callback runtime.FmCreateCallbackFn) error { ret := _m.Called(ctx, maxPlayers, userIds, latencies, metadata, callback) + if len(ret) == 0 { + panic("no return value specified for Create") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, int, []string, []runtime.FleetUserLatencies, map[string]interface{}, runtime.FmCreateCallbackFn) error); ok { r0 = rf(ctx, maxPlayers, userIds, latencies, metadata, callback) @@ -28,10 +40,47 @@ func (_m *MockFleetManagerInitializer) Create(ctx context.Context, maxPlayers in return r0 } +// MockFleetManagerInitializer_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockFleetManagerInitializer_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - maxPlayers int +// - userIds []string +// - latencies []runtime.FleetUserLatencies +// - metadata map[string]interface{} +// - callback runtime.FmCreateCallbackFn +func (_e *MockFleetManagerInitializer_Expecter) Create(ctx interface{}, maxPlayers interface{}, userIds interface{}, latencies interface{}, metadata interface{}, callback interface{}) *MockFleetManagerInitializer_Create_Call { + return &MockFleetManagerInitializer_Create_Call{Call: _e.mock.On("Create", ctx, maxPlayers, userIds, latencies, metadata, callback)} +} + +func (_c *MockFleetManagerInitializer_Create_Call) Run(run func(ctx context.Context, maxPlayers int, userIds []string, latencies []runtime.FleetUserLatencies, metadata map[string]interface{}, callback runtime.FmCreateCallbackFn)) *MockFleetManagerInitializer_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].([]string), args[3].([]runtime.FleetUserLatencies), args[4].(map[string]interface{}), args[5].(runtime.FmCreateCallbackFn)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Create_Call) Return(err error) *MockFleetManagerInitializer_Create_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockFleetManagerInitializer_Create_Call) RunAndReturn(run func(context.Context, int, []string, []runtime.FleetUserLatencies, map[string]interface{}, runtime.FmCreateCallbackFn) error) *MockFleetManagerInitializer_Create_Call { + _c.Call.Return(run) + return _c +} + // Delete provides a mock function with given fields: ctx, id func (_m *MockFleetManagerInitializer) Delete(ctx context.Context, id string) error { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for Delete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, id) @@ -42,10 +91,43 @@ func (_m *MockFleetManagerInitializer) Delete(ctx context.Context, id string) er return r0 } +// MockFleetManagerInitializer_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockFleetManagerInitializer_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockFleetManagerInitializer_Expecter) Delete(ctx interface{}, id interface{}) *MockFleetManagerInitializer_Delete_Call { + return &MockFleetManagerInitializer_Delete_Call{Call: _e.mock.On("Delete", ctx, id)} +} + +func (_c *MockFleetManagerInitializer_Delete_Call) Run(run func(ctx context.Context, id string)) *MockFleetManagerInitializer_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Delete_Call) Return(_a0 error) *MockFleetManagerInitializer_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockFleetManagerInitializer_Delete_Call) RunAndReturn(run func(context.Context, string) error) *MockFleetManagerInitializer_Delete_Call { + _c.Call.Return(run) + return _c +} + // Get provides a mock function with given fields: ctx, id func (_m *MockFleetManagerInitializer) Get(ctx context.Context, id string) (*runtime.InstanceInfo, error) { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for Get") + } + var r0 *runtime.InstanceInfo var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*runtime.InstanceInfo, error)); ok { @@ -68,10 +150,43 @@ func (_m *MockFleetManagerInitializer) Get(ctx context.Context, id string) (*run return r0, r1 } +// MockFleetManagerInitializer_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockFleetManagerInitializer_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockFleetManagerInitializer_Expecter) Get(ctx interface{}, id interface{}) *MockFleetManagerInitializer_Get_Call { + return &MockFleetManagerInitializer_Get_Call{Call: _e.mock.On("Get", ctx, id)} +} + +func (_c *MockFleetManagerInitializer_Get_Call) Run(run func(ctx context.Context, id string)) *MockFleetManagerInitializer_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Get_Call) Return(instance *runtime.InstanceInfo, err error) *MockFleetManagerInitializer_Get_Call { + _c.Call.Return(instance, err) + return _c +} + +func (_c *MockFleetManagerInitializer_Get_Call) RunAndReturn(run func(context.Context, string) (*runtime.InstanceInfo, error)) *MockFleetManagerInitializer_Get_Call { + _c.Call.Return(run) + return _c +} + // Init provides a mock function with given fields: nk, callbackHandler func (_m *MockFleetManagerInitializer) Init(nk runtime.NakamaModule, callbackHandler runtime.FmCallbackHandler) error { ret := _m.Called(nk, callbackHandler) + if len(ret) == 0 { + panic("no return value specified for Init") + } + var r0 error if rf, ok := ret.Get(0).(func(runtime.NakamaModule, runtime.FmCallbackHandler) error); ok { r0 = rf(nk, callbackHandler) @@ -82,10 +197,43 @@ func (_m *MockFleetManagerInitializer) Init(nk runtime.NakamaModule, callbackHan return r0 } +// MockFleetManagerInitializer_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockFleetManagerInitializer_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +// - nk runtime.NakamaModule +// - callbackHandler runtime.FmCallbackHandler +func (_e *MockFleetManagerInitializer_Expecter) Init(nk interface{}, callbackHandler interface{}) *MockFleetManagerInitializer_Init_Call { + return &MockFleetManagerInitializer_Init_Call{Call: _e.mock.On("Init", nk, callbackHandler)} +} + +func (_c *MockFleetManagerInitializer_Init_Call) Run(run func(nk runtime.NakamaModule, callbackHandler runtime.FmCallbackHandler)) *MockFleetManagerInitializer_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.NakamaModule), args[1].(runtime.FmCallbackHandler)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Init_Call) Return(_a0 error) *MockFleetManagerInitializer_Init_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockFleetManagerInitializer_Init_Call) RunAndReturn(run func(runtime.NakamaModule, runtime.FmCallbackHandler) error) *MockFleetManagerInitializer_Init_Call { + _c.Call.Return(run) + return _c +} + // Join provides a mock function with given fields: ctx, id, userIds, metadata func (_m *MockFleetManagerInitializer) Join(ctx context.Context, id string, userIds []string, metadata map[string]string) (*runtime.JoinInfo, error) { ret := _m.Called(ctx, id, userIds, metadata) + if len(ret) == 0 { + panic("no return value specified for Join") + } + var r0 *runtime.JoinInfo var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, []string, map[string]string) (*runtime.JoinInfo, error)); ok { @@ -108,10 +256,45 @@ func (_m *MockFleetManagerInitializer) Join(ctx context.Context, id string, user return r0, r1 } +// MockFleetManagerInitializer_Join_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Join' +type MockFleetManagerInitializer_Join_Call struct { + *mock.Call +} + +// Join is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userIds []string +// - metadata map[string]string +func (_e *MockFleetManagerInitializer_Expecter) Join(ctx interface{}, id interface{}, userIds interface{}, metadata interface{}) *MockFleetManagerInitializer_Join_Call { + return &MockFleetManagerInitializer_Join_Call{Call: _e.mock.On("Join", ctx, id, userIds, metadata)} +} + +func (_c *MockFleetManagerInitializer_Join_Call) Run(run func(ctx context.Context, id string, userIds []string, metadata map[string]string)) *MockFleetManagerInitializer_Join_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(map[string]string)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Join_Call) Return(joinInfo *runtime.JoinInfo, err error) *MockFleetManagerInitializer_Join_Call { + _c.Call.Return(joinInfo, err) + return _c +} + +func (_c *MockFleetManagerInitializer_Join_Call) RunAndReturn(run func(context.Context, string, []string, map[string]string) (*runtime.JoinInfo, error)) *MockFleetManagerInitializer_Join_Call { + _c.Call.Return(run) + return _c +} + // List provides a mock function with given fields: ctx, query, limit, previousCursor func (_m *MockFleetManagerInitializer) List(ctx context.Context, query string, limit int, previousCursor string) ([]*runtime.InstanceInfo, string, error) { ret := _m.Called(ctx, query, limit, previousCursor) + if len(ret) == 0 { + panic("no return value specified for List") + } + var r0 []*runtime.InstanceInfo var r1 string var r2 error @@ -141,10 +324,45 @@ func (_m *MockFleetManagerInitializer) List(ctx context.Context, query string, l return r0, r1, r2 } +// MockFleetManagerInitializer_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List' +type MockFleetManagerInitializer_List_Call struct { + *mock.Call +} + +// List is a helper method to define mock.On call +// - ctx context.Context +// - query string +// - limit int +// - previousCursor string +func (_e *MockFleetManagerInitializer_Expecter) List(ctx interface{}, query interface{}, limit interface{}, previousCursor interface{}) *MockFleetManagerInitializer_List_Call { + return &MockFleetManagerInitializer_List_Call{Call: _e.mock.On("List", ctx, query, limit, previousCursor)} +} + +func (_c *MockFleetManagerInitializer_List_Call) Run(run func(ctx context.Context, query string, limit int, previousCursor string)) *MockFleetManagerInitializer_List_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_List_Call) Return(list []*runtime.InstanceInfo, nextCursor string, err error) *MockFleetManagerInitializer_List_Call { + _c.Call.Return(list, nextCursor, err) + return _c +} + +func (_c *MockFleetManagerInitializer_List_Call) RunAndReturn(run func(context.Context, string, int, string) ([]*runtime.InstanceInfo, string, error)) *MockFleetManagerInitializer_List_Call { + _c.Call.Return(run) + return _c +} + // Update provides a mock function with given fields: ctx, id, playerCount, metadata func (_m *MockFleetManagerInitializer) Update(ctx context.Context, id string, playerCount int, metadata map[string]interface{}) error { ret := _m.Called(ctx, id, playerCount, metadata) + if len(ret) == 0 { + panic("no return value specified for Update") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, int, map[string]interface{}) error); ok { r0 = rf(ctx, id, playerCount, metadata) @@ -155,13 +373,43 @@ func (_m *MockFleetManagerInitializer) Update(ctx context.Context, id string, pl return r0 } -type mockConstructorTestingTNewMockFleetManagerInitializer interface { - mock.TestingT - Cleanup(func()) +// MockFleetManagerInitializer_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type MockFleetManagerInitializer_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - playerCount int +// - metadata map[string]interface{} +func (_e *MockFleetManagerInitializer_Expecter) Update(ctx interface{}, id interface{}, playerCount interface{}, metadata interface{}) *MockFleetManagerInitializer_Update_Call { + return &MockFleetManagerInitializer_Update_Call{Call: _e.mock.On("Update", ctx, id, playerCount, metadata)} +} + +func (_c *MockFleetManagerInitializer_Update_Call) Run(run func(ctx context.Context, id string, playerCount int, metadata map[string]interface{})) *MockFleetManagerInitializer_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(map[string]interface{})) + }) + return _c +} + +func (_c *MockFleetManagerInitializer_Update_Call) Return(_a0 error) *MockFleetManagerInitializer_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockFleetManagerInitializer_Update_Call) RunAndReturn(run func(context.Context, string, int, map[string]interface{}) error) *MockFleetManagerInitializer_Update_Call { + _c.Call.Return(run) + return _c } // NewMockFleetManagerInitializer creates a new instance of MockFleetManagerInitializer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockFleetManagerInitializer(t mockConstructorTestingTNewMockFleetManagerInitializer) *MockFleetManagerInitializer { +// The first argument is typically a *testing.T value. +func NewMockFleetManagerInitializer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockFleetManagerInitializer { mock := &MockFleetManagerInitializer{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_FmCallbackHandler.go b/relay/nakama/mocks/mock_FmCallbackHandler.go index 4f88e6e94..330ec1fa7 100644 --- a/relay/nakama/mocks/mock_FmCallbackHandler.go +++ b/relay/nakama/mocks/mock_FmCallbackHandler.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockFmCallbackHandler struct { mock.Mock } -// GenerateCallbackId provides a mock function with given fields: +type MockFmCallbackHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFmCallbackHandler) EXPECT() *MockFmCallbackHandler_Expecter { + return &MockFmCallbackHandler_Expecter{mock: &_m.Mock} +} + +// GenerateCallbackId provides a mock function with no fields func (_m *MockFmCallbackHandler) GenerateCallbackId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GenerateCallbackId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -26,23 +38,111 @@ func (_m *MockFmCallbackHandler) GenerateCallbackId() string { return r0 } +// MockFmCallbackHandler_GenerateCallbackId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateCallbackId' +type MockFmCallbackHandler_GenerateCallbackId_Call struct { + *mock.Call +} + +// GenerateCallbackId is a helper method to define mock.On call +func (_e *MockFmCallbackHandler_Expecter) GenerateCallbackId() *MockFmCallbackHandler_GenerateCallbackId_Call { + return &MockFmCallbackHandler_GenerateCallbackId_Call{Call: _e.mock.On("GenerateCallbackId")} +} + +func (_c *MockFmCallbackHandler_GenerateCallbackId_Call) Run(run func()) *MockFmCallbackHandler_GenerateCallbackId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockFmCallbackHandler_GenerateCallbackId_Call) Return(_a0 string) *MockFmCallbackHandler_GenerateCallbackId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockFmCallbackHandler_GenerateCallbackId_Call) RunAndReturn(run func() string) *MockFmCallbackHandler_GenerateCallbackId_Call { + _c.Call.Return(run) + return _c +} + // InvokeCallback provides a mock function with given fields: callbackId, status, instanceInfo, sessionInfo, metadata, err func (_m *MockFmCallbackHandler) InvokeCallback(callbackId string, status runtime.FmCreateStatus, instanceInfo *runtime.InstanceInfo, sessionInfo []*runtime.SessionInfo, metadata map[string]interface{}, err error) { _m.Called(callbackId, status, instanceInfo, sessionInfo, metadata, err) } +// MockFmCallbackHandler_InvokeCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvokeCallback' +type MockFmCallbackHandler_InvokeCallback_Call struct { + *mock.Call +} + +// InvokeCallback is a helper method to define mock.On call +// - callbackId string +// - status runtime.FmCreateStatus +// - instanceInfo *runtime.InstanceInfo +// - sessionInfo []*runtime.SessionInfo +// - metadata map[string]interface{} +// - err error +func (_e *MockFmCallbackHandler_Expecter) InvokeCallback(callbackId interface{}, status interface{}, instanceInfo interface{}, sessionInfo interface{}, metadata interface{}, err interface{}) *MockFmCallbackHandler_InvokeCallback_Call { + return &MockFmCallbackHandler_InvokeCallback_Call{Call: _e.mock.On("InvokeCallback", callbackId, status, instanceInfo, sessionInfo, metadata, err)} +} + +func (_c *MockFmCallbackHandler_InvokeCallback_Call) Run(run func(callbackId string, status runtime.FmCreateStatus, instanceInfo *runtime.InstanceInfo, sessionInfo []*runtime.SessionInfo, metadata map[string]interface{}, err error)) *MockFmCallbackHandler_InvokeCallback_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(runtime.FmCreateStatus), args[2].(*runtime.InstanceInfo), args[3].([]*runtime.SessionInfo), args[4].(map[string]interface{}), args[5].(error)) + }) + return _c +} + +func (_c *MockFmCallbackHandler_InvokeCallback_Call) Return() *MockFmCallbackHandler_InvokeCallback_Call { + _c.Call.Return() + return _c +} + +func (_c *MockFmCallbackHandler_InvokeCallback_Call) RunAndReturn(run func(string, runtime.FmCreateStatus, *runtime.InstanceInfo, []*runtime.SessionInfo, map[string]interface{}, error)) *MockFmCallbackHandler_InvokeCallback_Call { + _c.Run(run) + return _c +} + // SetCallback provides a mock function with given fields: callbackId, fn func (_m *MockFmCallbackHandler) SetCallback(callbackId string, fn runtime.FmCreateCallbackFn) { _m.Called(callbackId, fn) } -type mockConstructorTestingTNewMockFmCallbackHandler interface { - mock.TestingT - Cleanup(func()) +// MockFmCallbackHandler_SetCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallback' +type MockFmCallbackHandler_SetCallback_Call struct { + *mock.Call +} + +// SetCallback is a helper method to define mock.On call +// - callbackId string +// - fn runtime.FmCreateCallbackFn +func (_e *MockFmCallbackHandler_Expecter) SetCallback(callbackId interface{}, fn interface{}) *MockFmCallbackHandler_SetCallback_Call { + return &MockFmCallbackHandler_SetCallback_Call{Call: _e.mock.On("SetCallback", callbackId, fn)} +} + +func (_c *MockFmCallbackHandler_SetCallback_Call) Run(run func(callbackId string, fn runtime.FmCreateCallbackFn)) *MockFmCallbackHandler_SetCallback_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(runtime.FmCreateCallbackFn)) + }) + return _c +} + +func (_c *MockFmCallbackHandler_SetCallback_Call) Return() *MockFmCallbackHandler_SetCallback_Call { + _c.Call.Return() + return _c +} + +func (_c *MockFmCallbackHandler_SetCallback_Call) RunAndReturn(run func(string, runtime.FmCreateCallbackFn)) *MockFmCallbackHandler_SetCallback_Call { + _c.Run(run) + return _c } // NewMockFmCallbackHandler creates a new instance of MockFmCallbackHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockFmCallbackHandler(t mockConstructorTestingTNewMockFmCallbackHandler) *MockFmCallbackHandler { +// The first argument is typically a *testing.T value. +func NewMockFmCallbackHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *MockFmCallbackHandler { mock := &MockFmCallbackHandler{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_FmCreateCallbackFn.go b/relay/nakama/mocks/mock_FmCreateCallbackFn.go index e7884f6f7..d966e0ba1 100644 --- a/relay/nakama/mocks/mock_FmCreateCallbackFn.go +++ b/relay/nakama/mocks/mock_FmCreateCallbackFn.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,18 +12,57 @@ type MockFmCreateCallbackFn struct { mock.Mock } +type MockFmCreateCallbackFn_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFmCreateCallbackFn) EXPECT() *MockFmCreateCallbackFn_Expecter { + return &MockFmCreateCallbackFn_Expecter{mock: &_m.Mock} +} + // Execute provides a mock function with given fields: status, instanceInfo, sessionInfo, metadata, err func (_m *MockFmCreateCallbackFn) Execute(status runtime.FmCreateStatus, instanceInfo *runtime.InstanceInfo, sessionInfo []*runtime.SessionInfo, metadata map[string]interface{}, err error) { _m.Called(status, instanceInfo, sessionInfo, metadata, err) } -type mockConstructorTestingTNewMockFmCreateCallbackFn interface { - mock.TestingT - Cleanup(func()) +// MockFmCreateCallbackFn_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockFmCreateCallbackFn_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - status runtime.FmCreateStatus +// - instanceInfo *runtime.InstanceInfo +// - sessionInfo []*runtime.SessionInfo +// - metadata map[string]interface{} +// - err error +func (_e *MockFmCreateCallbackFn_Expecter) Execute(status interface{}, instanceInfo interface{}, sessionInfo interface{}, metadata interface{}, err interface{}) *MockFmCreateCallbackFn_Execute_Call { + return &MockFmCreateCallbackFn_Execute_Call{Call: _e.mock.On("Execute", status, instanceInfo, sessionInfo, metadata, err)} +} + +func (_c *MockFmCreateCallbackFn_Execute_Call) Run(run func(status runtime.FmCreateStatus, instanceInfo *runtime.InstanceInfo, sessionInfo []*runtime.SessionInfo, metadata map[string]interface{}, err error)) *MockFmCreateCallbackFn_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.FmCreateStatus), args[1].(*runtime.InstanceInfo), args[2].([]*runtime.SessionInfo), args[3].(map[string]interface{}), args[4].(error)) + }) + return _c +} + +func (_c *MockFmCreateCallbackFn_Execute_Call) Return() *MockFmCreateCallbackFn_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockFmCreateCallbackFn_Execute_Call) RunAndReturn(run func(runtime.FmCreateStatus, *runtime.InstanceInfo, []*runtime.SessionInfo, map[string]interface{}, error)) *MockFmCreateCallbackFn_Execute_Call { + _c.Run(run) + return _c } // NewMockFmCreateCallbackFn creates a new instance of MockFmCreateCallbackFn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockFmCreateCallbackFn(t mockConstructorTestingTNewMockFmCreateCallbackFn) *MockFmCreateCallbackFn { +// The first argument is typically a *testing.T value. +func NewMockFmCreateCallbackFn(t interface { + mock.TestingT + Cleanup(func()) +}) *MockFmCreateCallbackFn { mock := &MockFmCreateCallbackFn{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_GoogleAuthConfig.go b/relay/nakama/mocks/mock_GoogleAuthConfig.go new file mode 100644 index 000000000..b7031398a --- /dev/null +++ b/relay/nakama/mocks/mock_GoogleAuthConfig.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockGoogleAuthConfig is an autogenerated mock type for the GoogleAuthConfig type +type MockGoogleAuthConfig struct { + mock.Mock +} + +type MockGoogleAuthConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockGoogleAuthConfig) EXPECT() *MockGoogleAuthConfig_Expecter { + return &MockGoogleAuthConfig_Expecter{mock: &_m.Mock} +} + +// GetCredentialsJSON provides a mock function with no fields +func (_m *MockGoogleAuthConfig) GetCredentialsJSON() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetCredentialsJSON") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockGoogleAuthConfig_GetCredentialsJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCredentialsJSON' +type MockGoogleAuthConfig_GetCredentialsJSON_Call struct { + *mock.Call +} + +// GetCredentialsJSON is a helper method to define mock.On call +func (_e *MockGoogleAuthConfig_Expecter) GetCredentialsJSON() *MockGoogleAuthConfig_GetCredentialsJSON_Call { + return &MockGoogleAuthConfig_GetCredentialsJSON_Call{Call: _e.mock.On("GetCredentialsJSON")} +} + +func (_c *MockGoogleAuthConfig_GetCredentialsJSON_Call) Run(run func()) *MockGoogleAuthConfig_GetCredentialsJSON_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockGoogleAuthConfig_GetCredentialsJSON_Call) Return(_a0 string) *MockGoogleAuthConfig_GetCredentialsJSON_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGoogleAuthConfig_GetCredentialsJSON_Call) RunAndReturn(run func() string) *MockGoogleAuthConfig_GetCredentialsJSON_Call { + _c.Call.Return(run) + return _c +} + +// NewMockGoogleAuthConfig creates a new instance of MockGoogleAuthConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGoogleAuthConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockGoogleAuthConfig { + mock := &MockGoogleAuthConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_IAPAppleConfig.go b/relay/nakama/mocks/mock_IAPAppleConfig.go new file mode 100644 index 000000000..f857ef30b --- /dev/null +++ b/relay/nakama/mocks/mock_IAPAppleConfig.go @@ -0,0 +1,122 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockIAPAppleConfig is an autogenerated mock type for the IAPAppleConfig type +type MockIAPAppleConfig struct { + mock.Mock +} + +type MockIAPAppleConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIAPAppleConfig) EXPECT() *MockIAPAppleConfig_Expecter { + return &MockIAPAppleConfig_Expecter{mock: &_m.Mock} +} + +// GetNotificationsEndpointId provides a mock function with no fields +func (_m *MockIAPAppleConfig) GetNotificationsEndpointId() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetNotificationsEndpointId") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPAppleConfig_GetNotificationsEndpointId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNotificationsEndpointId' +type MockIAPAppleConfig_GetNotificationsEndpointId_Call struct { + *mock.Call +} + +// GetNotificationsEndpointId is a helper method to define mock.On call +func (_e *MockIAPAppleConfig_Expecter) GetNotificationsEndpointId() *MockIAPAppleConfig_GetNotificationsEndpointId_Call { + return &MockIAPAppleConfig_GetNotificationsEndpointId_Call{Call: _e.mock.On("GetNotificationsEndpointId")} +} + +func (_c *MockIAPAppleConfig_GetNotificationsEndpointId_Call) Run(run func()) *MockIAPAppleConfig_GetNotificationsEndpointId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPAppleConfig_GetNotificationsEndpointId_Call) Return(_a0 string) *MockIAPAppleConfig_GetNotificationsEndpointId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPAppleConfig_GetNotificationsEndpointId_Call) RunAndReturn(run func() string) *MockIAPAppleConfig_GetNotificationsEndpointId_Call { + _c.Call.Return(run) + return _c +} + +// GetSharedPassword provides a mock function with no fields +func (_m *MockIAPAppleConfig) GetSharedPassword() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSharedPassword") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPAppleConfig_GetSharedPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSharedPassword' +type MockIAPAppleConfig_GetSharedPassword_Call struct { + *mock.Call +} + +// GetSharedPassword is a helper method to define mock.On call +func (_e *MockIAPAppleConfig_Expecter) GetSharedPassword() *MockIAPAppleConfig_GetSharedPassword_Call { + return &MockIAPAppleConfig_GetSharedPassword_Call{Call: _e.mock.On("GetSharedPassword")} +} + +func (_c *MockIAPAppleConfig_GetSharedPassword_Call) Run(run func()) *MockIAPAppleConfig_GetSharedPassword_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPAppleConfig_GetSharedPassword_Call) Return(_a0 string) *MockIAPAppleConfig_GetSharedPassword_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPAppleConfig_GetSharedPassword_Call) RunAndReturn(run func() string) *MockIAPAppleConfig_GetSharedPassword_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIAPAppleConfig creates a new instance of MockIAPAppleConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIAPAppleConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIAPAppleConfig { + mock := &MockIAPAppleConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_IAPConfig.go b/relay/nakama/mocks/mock_IAPConfig.go new file mode 100644 index 000000000..4bb59173c --- /dev/null +++ b/relay/nakama/mocks/mock_IAPConfig.go @@ -0,0 +1,223 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import ( + runtime "github.com/heroiclabs/nakama-common/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockIAPConfig is an autogenerated mock type for the IAPConfig type +type MockIAPConfig struct { + mock.Mock +} + +type MockIAPConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIAPConfig) EXPECT() *MockIAPConfig_Expecter { + return &MockIAPConfig_Expecter{mock: &_m.Mock} +} + +// GetApple provides a mock function with no fields +func (_m *MockIAPConfig) GetApple() runtime.IAPAppleConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetApple") + } + + var r0 runtime.IAPAppleConfig + if rf, ok := ret.Get(0).(func() runtime.IAPAppleConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.IAPAppleConfig) + } + } + + return r0 +} + +// MockIAPConfig_GetApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApple' +type MockIAPConfig_GetApple_Call struct { + *mock.Call +} + +// GetApple is a helper method to define mock.On call +func (_e *MockIAPConfig_Expecter) GetApple() *MockIAPConfig_GetApple_Call { + return &MockIAPConfig_GetApple_Call{Call: _e.mock.On("GetApple")} +} + +func (_c *MockIAPConfig_GetApple_Call) Run(run func()) *MockIAPConfig_GetApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPConfig_GetApple_Call) Return(_a0 runtime.IAPAppleConfig) *MockIAPConfig_GetApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPConfig_GetApple_Call) RunAndReturn(run func() runtime.IAPAppleConfig) *MockIAPConfig_GetApple_Call { + _c.Call.Return(run) + return _c +} + +// GetFacebookInstant provides a mock function with no fields +func (_m *MockIAPConfig) GetFacebookInstant() runtime.IAPFacebookInstantConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetFacebookInstant") + } + + var r0 runtime.IAPFacebookInstantConfig + if rf, ok := ret.Get(0).(func() runtime.IAPFacebookInstantConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.IAPFacebookInstantConfig) + } + } + + return r0 +} + +// MockIAPConfig_GetFacebookInstant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFacebookInstant' +type MockIAPConfig_GetFacebookInstant_Call struct { + *mock.Call +} + +// GetFacebookInstant is a helper method to define mock.On call +func (_e *MockIAPConfig_Expecter) GetFacebookInstant() *MockIAPConfig_GetFacebookInstant_Call { + return &MockIAPConfig_GetFacebookInstant_Call{Call: _e.mock.On("GetFacebookInstant")} +} + +func (_c *MockIAPConfig_GetFacebookInstant_Call) Run(run func()) *MockIAPConfig_GetFacebookInstant_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPConfig_GetFacebookInstant_Call) Return(_a0 runtime.IAPFacebookInstantConfig) *MockIAPConfig_GetFacebookInstant_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPConfig_GetFacebookInstant_Call) RunAndReturn(run func() runtime.IAPFacebookInstantConfig) *MockIAPConfig_GetFacebookInstant_Call { + _c.Call.Return(run) + return _c +} + +// GetGoogle provides a mock function with no fields +func (_m *MockIAPConfig) GetGoogle() runtime.IAPGoogleConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetGoogle") + } + + var r0 runtime.IAPGoogleConfig + if rf, ok := ret.Get(0).(func() runtime.IAPGoogleConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.IAPGoogleConfig) + } + } + + return r0 +} + +// MockIAPConfig_GetGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGoogle' +type MockIAPConfig_GetGoogle_Call struct { + *mock.Call +} + +// GetGoogle is a helper method to define mock.On call +func (_e *MockIAPConfig_Expecter) GetGoogle() *MockIAPConfig_GetGoogle_Call { + return &MockIAPConfig_GetGoogle_Call{Call: _e.mock.On("GetGoogle")} +} + +func (_c *MockIAPConfig_GetGoogle_Call) Run(run func()) *MockIAPConfig_GetGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPConfig_GetGoogle_Call) Return(_a0 runtime.IAPGoogleConfig) *MockIAPConfig_GetGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPConfig_GetGoogle_Call) RunAndReturn(run func() runtime.IAPGoogleConfig) *MockIAPConfig_GetGoogle_Call { + _c.Call.Return(run) + return _c +} + +// GetHuawei provides a mock function with no fields +func (_m *MockIAPConfig) GetHuawei() runtime.IAPHuaweiConfig { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetHuawei") + } + + var r0 runtime.IAPHuaweiConfig + if rf, ok := ret.Get(0).(func() runtime.IAPHuaweiConfig); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.IAPHuaweiConfig) + } + } + + return r0 +} + +// MockIAPConfig_GetHuawei_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHuawei' +type MockIAPConfig_GetHuawei_Call struct { + *mock.Call +} + +// GetHuawei is a helper method to define mock.On call +func (_e *MockIAPConfig_Expecter) GetHuawei() *MockIAPConfig_GetHuawei_Call { + return &MockIAPConfig_GetHuawei_Call{Call: _e.mock.On("GetHuawei")} +} + +func (_c *MockIAPConfig_GetHuawei_Call) Run(run func()) *MockIAPConfig_GetHuawei_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPConfig_GetHuawei_Call) Return(_a0 runtime.IAPHuaweiConfig) *MockIAPConfig_GetHuawei_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPConfig_GetHuawei_Call) RunAndReturn(run func() runtime.IAPHuaweiConfig) *MockIAPConfig_GetHuawei_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIAPConfig creates a new instance of MockIAPConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIAPConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIAPConfig { + mock := &MockIAPConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_IAPFacebookInstantConfig.go b/relay/nakama/mocks/mock_IAPFacebookInstantConfig.go new file mode 100644 index 000000000..e4edfcfd3 --- /dev/null +++ b/relay/nakama/mocks/mock_IAPFacebookInstantConfig.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockIAPFacebookInstantConfig is an autogenerated mock type for the IAPFacebookInstantConfig type +type MockIAPFacebookInstantConfig struct { + mock.Mock +} + +type MockIAPFacebookInstantConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIAPFacebookInstantConfig) EXPECT() *MockIAPFacebookInstantConfig_Expecter { + return &MockIAPFacebookInstantConfig_Expecter{mock: &_m.Mock} +} + +// GetAppSecret provides a mock function with no fields +func (_m *MockIAPFacebookInstantConfig) GetAppSecret() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAppSecret") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPFacebookInstantConfig_GetAppSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppSecret' +type MockIAPFacebookInstantConfig_GetAppSecret_Call struct { + *mock.Call +} + +// GetAppSecret is a helper method to define mock.On call +func (_e *MockIAPFacebookInstantConfig_Expecter) GetAppSecret() *MockIAPFacebookInstantConfig_GetAppSecret_Call { + return &MockIAPFacebookInstantConfig_GetAppSecret_Call{Call: _e.mock.On("GetAppSecret")} +} + +func (_c *MockIAPFacebookInstantConfig_GetAppSecret_Call) Run(run func()) *MockIAPFacebookInstantConfig_GetAppSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPFacebookInstantConfig_GetAppSecret_Call) Return(_a0 string) *MockIAPFacebookInstantConfig_GetAppSecret_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPFacebookInstantConfig_GetAppSecret_Call) RunAndReturn(run func() string) *MockIAPFacebookInstantConfig_GetAppSecret_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIAPFacebookInstantConfig creates a new instance of MockIAPFacebookInstantConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIAPFacebookInstantConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIAPFacebookInstantConfig { + mock := &MockIAPFacebookInstantConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_IAPGoogleConfig.go b/relay/nakama/mocks/mock_IAPGoogleConfig.go new file mode 100644 index 000000000..3d9094da7 --- /dev/null +++ b/relay/nakama/mocks/mock_IAPGoogleConfig.go @@ -0,0 +1,257 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockIAPGoogleConfig is an autogenerated mock type for the IAPGoogleConfig type +type MockIAPGoogleConfig struct { + mock.Mock +} + +type MockIAPGoogleConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIAPGoogleConfig) EXPECT() *MockIAPGoogleConfig_Expecter { + return &MockIAPGoogleConfig_Expecter{mock: &_m.Mock} +} + +// GetClientEmail provides a mock function with no fields +func (_m *MockIAPGoogleConfig) GetClientEmail() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetClientEmail") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPGoogleConfig_GetClientEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClientEmail' +type MockIAPGoogleConfig_GetClientEmail_Call struct { + *mock.Call +} + +// GetClientEmail is a helper method to define mock.On call +func (_e *MockIAPGoogleConfig_Expecter) GetClientEmail() *MockIAPGoogleConfig_GetClientEmail_Call { + return &MockIAPGoogleConfig_GetClientEmail_Call{Call: _e.mock.On("GetClientEmail")} +} + +func (_c *MockIAPGoogleConfig_GetClientEmail_Call) Run(run func()) *MockIAPGoogleConfig_GetClientEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPGoogleConfig_GetClientEmail_Call) Return(_a0 string) *MockIAPGoogleConfig_GetClientEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPGoogleConfig_GetClientEmail_Call) RunAndReturn(run func() string) *MockIAPGoogleConfig_GetClientEmail_Call { + _c.Call.Return(run) + return _c +} + +// GetNotificationsEndpointId provides a mock function with no fields +func (_m *MockIAPGoogleConfig) GetNotificationsEndpointId() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetNotificationsEndpointId") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPGoogleConfig_GetNotificationsEndpointId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNotificationsEndpointId' +type MockIAPGoogleConfig_GetNotificationsEndpointId_Call struct { + *mock.Call +} + +// GetNotificationsEndpointId is a helper method to define mock.On call +func (_e *MockIAPGoogleConfig_Expecter) GetNotificationsEndpointId() *MockIAPGoogleConfig_GetNotificationsEndpointId_Call { + return &MockIAPGoogleConfig_GetNotificationsEndpointId_Call{Call: _e.mock.On("GetNotificationsEndpointId")} +} + +func (_c *MockIAPGoogleConfig_GetNotificationsEndpointId_Call) Run(run func()) *MockIAPGoogleConfig_GetNotificationsEndpointId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPGoogleConfig_GetNotificationsEndpointId_Call) Return(_a0 string) *MockIAPGoogleConfig_GetNotificationsEndpointId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPGoogleConfig_GetNotificationsEndpointId_Call) RunAndReturn(run func() string) *MockIAPGoogleConfig_GetNotificationsEndpointId_Call { + _c.Call.Return(run) + return _c +} + +// GetPackageName provides a mock function with no fields +func (_m *MockIAPGoogleConfig) GetPackageName() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPackageName") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPGoogleConfig_GetPackageName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPackageName' +type MockIAPGoogleConfig_GetPackageName_Call struct { + *mock.Call +} + +// GetPackageName is a helper method to define mock.On call +func (_e *MockIAPGoogleConfig_Expecter) GetPackageName() *MockIAPGoogleConfig_GetPackageName_Call { + return &MockIAPGoogleConfig_GetPackageName_Call{Call: _e.mock.On("GetPackageName")} +} + +func (_c *MockIAPGoogleConfig_GetPackageName_Call) Run(run func()) *MockIAPGoogleConfig_GetPackageName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPGoogleConfig_GetPackageName_Call) Return(_a0 string) *MockIAPGoogleConfig_GetPackageName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPGoogleConfig_GetPackageName_Call) RunAndReturn(run func() string) *MockIAPGoogleConfig_GetPackageName_Call { + _c.Call.Return(run) + return _c +} + +// GetPrivateKey provides a mock function with no fields +func (_m *MockIAPGoogleConfig) GetPrivateKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPrivateKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPGoogleConfig_GetPrivateKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrivateKey' +type MockIAPGoogleConfig_GetPrivateKey_Call struct { + *mock.Call +} + +// GetPrivateKey is a helper method to define mock.On call +func (_e *MockIAPGoogleConfig_Expecter) GetPrivateKey() *MockIAPGoogleConfig_GetPrivateKey_Call { + return &MockIAPGoogleConfig_GetPrivateKey_Call{Call: _e.mock.On("GetPrivateKey")} +} + +func (_c *MockIAPGoogleConfig_GetPrivateKey_Call) Run(run func()) *MockIAPGoogleConfig_GetPrivateKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPGoogleConfig_GetPrivateKey_Call) Return(_a0 string) *MockIAPGoogleConfig_GetPrivateKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPGoogleConfig_GetPrivateKey_Call) RunAndReturn(run func() string) *MockIAPGoogleConfig_GetPrivateKey_Call { + _c.Call.Return(run) + return _c +} + +// GetRefundCheckPeriodMin provides a mock function with no fields +func (_m *MockIAPGoogleConfig) GetRefundCheckPeriodMin() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRefundCheckPeriodMin") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefundCheckPeriodMin' +type MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call struct { + *mock.Call +} + +// GetRefundCheckPeriodMin is a helper method to define mock.On call +func (_e *MockIAPGoogleConfig_Expecter) GetRefundCheckPeriodMin() *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call { + return &MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call{Call: _e.mock.On("GetRefundCheckPeriodMin")} +} + +func (_c *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call) Run(run func()) *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call) Return(_a0 int) *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call) RunAndReturn(run func() int) *MockIAPGoogleConfig_GetRefundCheckPeriodMin_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIAPGoogleConfig creates a new instance of MockIAPGoogleConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIAPGoogleConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIAPGoogleConfig { + mock := &MockIAPGoogleConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_IAPHuaweiConfig.go b/relay/nakama/mocks/mock_IAPHuaweiConfig.go new file mode 100644 index 000000000..883eb3608 --- /dev/null +++ b/relay/nakama/mocks/mock_IAPHuaweiConfig.go @@ -0,0 +1,167 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockIAPHuaweiConfig is an autogenerated mock type for the IAPHuaweiConfig type +type MockIAPHuaweiConfig struct { + mock.Mock +} + +type MockIAPHuaweiConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIAPHuaweiConfig) EXPECT() *MockIAPHuaweiConfig_Expecter { + return &MockIAPHuaweiConfig_Expecter{mock: &_m.Mock} +} + +// GetClientID provides a mock function with no fields +func (_m *MockIAPHuaweiConfig) GetClientID() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetClientID") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPHuaweiConfig_GetClientID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClientID' +type MockIAPHuaweiConfig_GetClientID_Call struct { + *mock.Call +} + +// GetClientID is a helper method to define mock.On call +func (_e *MockIAPHuaweiConfig_Expecter) GetClientID() *MockIAPHuaweiConfig_GetClientID_Call { + return &MockIAPHuaweiConfig_GetClientID_Call{Call: _e.mock.On("GetClientID")} +} + +func (_c *MockIAPHuaweiConfig_GetClientID_Call) Run(run func()) *MockIAPHuaweiConfig_GetClientID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetClientID_Call) Return(_a0 string) *MockIAPHuaweiConfig_GetClientID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetClientID_Call) RunAndReturn(run func() string) *MockIAPHuaweiConfig_GetClientID_Call { + _c.Call.Return(run) + return _c +} + +// GetClientSecret provides a mock function with no fields +func (_m *MockIAPHuaweiConfig) GetClientSecret() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetClientSecret") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPHuaweiConfig_GetClientSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClientSecret' +type MockIAPHuaweiConfig_GetClientSecret_Call struct { + *mock.Call +} + +// GetClientSecret is a helper method to define mock.On call +func (_e *MockIAPHuaweiConfig_Expecter) GetClientSecret() *MockIAPHuaweiConfig_GetClientSecret_Call { + return &MockIAPHuaweiConfig_GetClientSecret_Call{Call: _e.mock.On("GetClientSecret")} +} + +func (_c *MockIAPHuaweiConfig_GetClientSecret_Call) Run(run func()) *MockIAPHuaweiConfig_GetClientSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetClientSecret_Call) Return(_a0 string) *MockIAPHuaweiConfig_GetClientSecret_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetClientSecret_Call) RunAndReturn(run func() string) *MockIAPHuaweiConfig_GetClientSecret_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicKey provides a mock function with no fields +func (_m *MockIAPHuaweiConfig) GetPublicKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPublicKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIAPHuaweiConfig_GetPublicKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicKey' +type MockIAPHuaweiConfig_GetPublicKey_Call struct { + *mock.Call +} + +// GetPublicKey is a helper method to define mock.On call +func (_e *MockIAPHuaweiConfig_Expecter) GetPublicKey() *MockIAPHuaweiConfig_GetPublicKey_Call { + return &MockIAPHuaweiConfig_GetPublicKey_Call{Call: _e.mock.On("GetPublicKey")} +} + +func (_c *MockIAPHuaweiConfig_GetPublicKey_Call) Run(run func()) *MockIAPHuaweiConfig_GetPublicKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetPublicKey_Call) Return(_a0 string) *MockIAPHuaweiConfig_GetPublicKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIAPHuaweiConfig_GetPublicKey_Call) RunAndReturn(run func() string) *MockIAPHuaweiConfig_GetPublicKey_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIAPHuaweiConfig creates a new instance of MockIAPHuaweiConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIAPHuaweiConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIAPHuaweiConfig { + mock := &MockIAPHuaweiConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_Initializer.go b/relay/nakama/mocks/mock_Initializer.go index ca3f36ecf..a02847b60 100644 --- a/relay/nakama/mocks/mock_Initializer.go +++ b/relay/nakama/mocks/mock_Initializer.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -7,6 +7,8 @@ import ( api "github.com/heroiclabs/nakama-common/api" + http "net/http" + mock "github.com/stretchr/testify/mock" rtapi "github.com/heroiclabs/nakama-common/rtapi" @@ -21,10 +23,79 @@ type MockInitializer struct { mock.Mock } +type MockInitializer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockInitializer) EXPECT() *MockInitializer_Expecter { + return &MockInitializer_Expecter{mock: &_m.Mock} +} + +// GetConfig provides a mock function with no fields +func (_m *MockInitializer) GetConfig() (runtime.Config, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetConfig") + } + + var r0 runtime.Config + var r1 error + if rf, ok := ret.Get(0).(func() (runtime.Config, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() runtime.Config); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.Config) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockInitializer_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig' +type MockInitializer_GetConfig_Call struct { + *mock.Call +} + +// GetConfig is a helper method to define mock.On call +func (_e *MockInitializer_Expecter) GetConfig() *MockInitializer_GetConfig_Call { + return &MockInitializer_GetConfig_Call{Call: _e.mock.On("GetConfig")} +} + +func (_c *MockInitializer_GetConfig_Call) Run(run func()) *MockInitializer_GetConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockInitializer_GetConfig_Call) Return(_a0 runtime.Config, _a1 error) *MockInitializer_GetConfig_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockInitializer_GetConfig_Call) RunAndReturn(run func() (runtime.Config, error)) *MockInitializer_GetConfig_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAddFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAddFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAddFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error); ok { r0 = rf(fn) @@ -35,10 +106,42 @@ func (_m *MockInitializer) RegisterAfterAddFriends(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterAddFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAddFriends' +type MockInitializer_RegisterAfterAddFriends_Call struct { + *mock.Call +} + +// RegisterAfterAddFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddFriendsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAddFriends(fn interface{}) *MockInitializer_RegisterAfterAddFriends_Call { + return &MockInitializer_RegisterAfterAddFriends_Call{Call: _e.mock.On("RegisterAfterAddFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterAddFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error)) *MockInitializer_RegisterAfterAddFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAddFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterAddFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAddFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error) *MockInitializer_RegisterAfterAddFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAddGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAddGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAddGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -49,10 +152,42 @@ func (_m *MockInitializer) RegisterAfterAddGroupUsers(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterAddGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAddGroupUsers' +type MockInitializer_RegisterAfterAddGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterAddGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAddGroupUsers(fn interface{}) *MockInitializer_RegisterAfterAddGroupUsers_Call { + return &MockInitializer_RegisterAfterAddGroupUsers_Call{Call: _e.mock.On("RegisterAfterAddGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error)) *MockInitializer_RegisterAfterAddGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterAddGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error) *MockInitializer_RegisterAfterAddGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error); ok { r0 = rf(fn) @@ -63,10 +198,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateApple(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterAuthenticateApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateApple' +type MockInitializer_RegisterAfterAuthenticateApple_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateAppleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateApple(fn interface{}) *MockInitializer_RegisterAfterAuthenticateApple_Call { + return &MockInitializer_RegisterAfterAuthenticateApple_Call{Call: _e.mock.On("RegisterAfterAuthenticateApple", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error)) *MockInitializer_RegisterAfterAuthenticateApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error) *MockInitializer_RegisterAfterAuthenticateApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error); ok { r0 = rf(fn) @@ -77,10 +244,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateCustom(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterAuthenticateCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateCustom' +type MockInitializer_RegisterAfterAuthenticateCustom_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateCustomRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateCustom(fn interface{}) *MockInitializer_RegisterAfterAuthenticateCustom_Call { + return &MockInitializer_RegisterAfterAuthenticateCustom_Call{Call: _e.mock.On("RegisterAfterAuthenticateCustom", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error)) *MockInitializer_RegisterAfterAuthenticateCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error) *MockInitializer_RegisterAfterAuthenticateCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error); ok { r0 = rf(fn) @@ -91,10 +290,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateDevice(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterAuthenticateDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateDevice' +type MockInitializer_RegisterAfterAuthenticateDevice_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateDeviceRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateDevice(fn interface{}) *MockInitializer_RegisterAfterAuthenticateDevice_Call { + return &MockInitializer_RegisterAfterAuthenticateDevice_Call{Call: _e.mock.On("RegisterAfterAuthenticateDevice", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error)) *MockInitializer_RegisterAfterAuthenticateDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error) *MockInitializer_RegisterAfterAuthenticateDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error); ok { r0 = rf(fn) @@ -105,10 +336,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateEmail(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterAuthenticateEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateEmail' +type MockInitializer_RegisterAfterAuthenticateEmail_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateEmailRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateEmail(fn interface{}) *MockInitializer_RegisterAfterAuthenticateEmail_Call { + return &MockInitializer_RegisterAfterAuthenticateEmail_Call{Call: _e.mock.On("RegisterAfterAuthenticateEmail", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error)) *MockInitializer_RegisterAfterAuthenticateEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error) *MockInitializer_RegisterAfterAuthenticateEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error); ok { r0 = rf(fn) @@ -119,10 +382,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateFacebook(fn func(context.Con return r0 } +// MockInitializer_RegisterAfterAuthenticateFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateFacebook' +type MockInitializer_RegisterAfterAuthenticateFacebook_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateFacebookRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateFacebook(fn interface{}) *MockInitializer_RegisterAfterAuthenticateFacebook_Call { + return &MockInitializer_RegisterAfterAuthenticateFacebook_Call{Call: _e.mock.On("RegisterAfterAuthenticateFacebook", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error)) *MockInitializer_RegisterAfterAuthenticateFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error) *MockInitializer_RegisterAfterAuthenticateFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error); ok { r0 = rf(fn) @@ -133,10 +428,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateFacebookInstantGame(fn func( return r0 } +// MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateFacebookInstantGame' +type MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateFacebookInstantGameRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call { + return &MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterAuthenticateFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error)) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error); ok { r0 = rf(fn) @@ -147,10 +474,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateGameCenter(fn func(context.C return r0 } +// MockInitializer_RegisterAfterAuthenticateGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateGameCenter' +type MockInitializer_RegisterAfterAuthenticateGameCenter_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateGameCenterRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateGameCenter(fn interface{}) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call { + return &MockInitializer_RegisterAfterAuthenticateGameCenter_Call{Call: _e.mock.On("RegisterAfterAuthenticateGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error)) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error); ok { r0 = rf(fn) @@ -161,10 +520,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateGoogle(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterAuthenticateGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateGoogle' +type MockInitializer_RegisterAfterAuthenticateGoogle_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateGoogleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateGoogle(fn interface{}) *MockInitializer_RegisterAfterAuthenticateGoogle_Call { + return &MockInitializer_RegisterAfterAuthenticateGoogle_Call{Call: _e.mock.On("RegisterAfterAuthenticateGoogle", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error)) *MockInitializer_RegisterAfterAuthenticateGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error) *MockInitializer_RegisterAfterAuthenticateGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterAuthenticateSteam provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterAuthenticateSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterAuthenticateSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error); ok { r0 = rf(fn) @@ -175,10 +566,42 @@ func (_m *MockInitializer) RegisterAfterAuthenticateSteam(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterAuthenticateSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterAuthenticateSteam' +type MockInitializer_RegisterAfterAuthenticateSteam_Call struct { + *mock.Call +} + +// RegisterAfterAuthenticateSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateSteamRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateSteam(fn interface{}) *MockInitializer_RegisterAfterAuthenticateSteam_Call { + return &MockInitializer_RegisterAfterAuthenticateSteam_Call{Call: _e.mock.On("RegisterAfterAuthenticateSteam", fn)} +} + +func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error)) *MockInitializer_RegisterAfterAuthenticateSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error) *MockInitializer_RegisterAfterAuthenticateSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterBanGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterBanGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterBanGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -189,10 +612,42 @@ func (_m *MockInitializer) RegisterAfterBanGroupUsers(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterBanGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterBanGroupUsers' +type MockInitializer_RegisterAfterBanGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterBanGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BanGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterBanGroupUsers(fn interface{}) *MockInitializer_RegisterAfterBanGroupUsers_Call { + return &MockInitializer_RegisterAfterBanGroupUsers_Call{Call: _e.mock.On("RegisterAfterBanGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error)) *MockInitializer_RegisterAfterBanGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterBanGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error) *MockInitializer_RegisterAfterBanGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterBlockFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterBlockFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterBlockFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error); ok { r0 = rf(fn) @@ -203,10 +658,42 @@ func (_m *MockInitializer) RegisterAfterBlockFriends(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterAfterBlockFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterBlockFriends' +type MockInitializer_RegisterAfterBlockFriends_Call struct { + *mock.Call +} + +// RegisterAfterBlockFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BlockFriendsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterBlockFriends(fn interface{}) *MockInitializer_RegisterAfterBlockFriends_Call { + return &MockInitializer_RegisterAfterBlockFriends_Call{Call: _e.mock.On("RegisterAfterBlockFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterBlockFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error)) *MockInitializer_RegisterAfterBlockFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterBlockFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterBlockFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterBlockFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error) *MockInitializer_RegisterAfterBlockFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterCreateGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterCreateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterCreateGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error); ok { r0 = rf(fn) @@ -217,10 +704,42 @@ func (_m *MockInitializer) RegisterAfterCreateGroup(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterCreateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterCreateGroup' +type MockInitializer_RegisterAfterCreateGroup_Call struct { + *mock.Call +} + +// RegisterAfterCreateGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Group , *api.CreateGroupRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterCreateGroup(fn interface{}) *MockInitializer_RegisterAfterCreateGroup_Call { + return &MockInitializer_RegisterAfterCreateGroup_Call{Call: _e.mock.On("RegisterAfterCreateGroup", fn)} +} + +func (_c *MockInitializer_RegisterAfterCreateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error)) *MockInitializer_RegisterAfterCreateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterCreateGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterCreateGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterCreateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error) *MockInitializer_RegisterAfterCreateGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteAccount provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteAccount") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok { r0 = rf(fn) @@ -231,10 +750,42 @@ func (_m *MockInitializer) RegisterAfterDeleteAccount(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterDeleteAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteAccount' +type MockInitializer_RegisterAfterDeleteAccount_Call struct { + *mock.Call +} + +// RegisterAfterDeleteAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteAccount(fn interface{}) *MockInitializer_RegisterAfterDeleteAccount_Call { + return &MockInitializer_RegisterAfterDeleteAccount_Call{Call: _e.mock.On("RegisterAfterDeleteAccount", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterAfterDeleteAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterAfterDeleteAccount_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error); ok { r0 = rf(fn) @@ -245,10 +796,42 @@ func (_m *MockInitializer) RegisterAfterDeleteFriends(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterDeleteFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteFriends' +type MockInitializer_RegisterAfterDeleteFriends_Call struct { + *mock.Call +} + +// RegisterAfterDeleteFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteFriendsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteFriends(fn interface{}) *MockInitializer_RegisterAfterDeleteFriends_Call { + return &MockInitializer_RegisterAfterDeleteFriends_Call{Call: _e.mock.On("RegisterAfterDeleteFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error)) *MockInitializer_RegisterAfterDeleteFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error) *MockInitializer_RegisterAfterDeleteFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error); ok { r0 = rf(fn) @@ -259,10 +842,42 @@ func (_m *MockInitializer) RegisterAfterDeleteGroup(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterDeleteGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteGroup' +type MockInitializer_RegisterAfterDeleteGroup_Call struct { + *mock.Call +} + +// RegisterAfterDeleteGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteGroupRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteGroup(fn interface{}) *MockInitializer_RegisterAfterDeleteGroup_Call { + return &MockInitializer_RegisterAfterDeleteGroup_Call{Call: _e.mock.On("RegisterAfterDeleteGroup", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error)) *MockInitializer_RegisterAfterDeleteGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error) *MockInitializer_RegisterAfterDeleteGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteLeaderboardRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteLeaderboardRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error); ok { r0 = rf(fn) @@ -273,10 +888,42 @@ func (_m *MockInitializer) RegisterAfterDeleteLeaderboardRecord(fn func(context. return r0 } +// MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteLeaderboardRecord' +type MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call struct { + *mock.Call +} + +// RegisterAfterDeleteLeaderboardRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteLeaderboardRecordRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call { + return &MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call{Call: _e.mock.On("RegisterAfterDeleteLeaderboardRecord", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error)) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteNotifications provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteNotifications") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error); ok { r0 = rf(fn) @@ -287,11 +934,43 @@ func (_m *MockInitializer) RegisterAfterDeleteNotifications(fn func(context.Cont return r0 } +// MockInitializer_RegisterAfterDeleteNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteNotifications' +type MockInitializer_RegisterAfterDeleteNotifications_Call struct { + *mock.Call +} + +// RegisterAfterDeleteNotifications is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteNotificationsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteNotifications(fn interface{}) *MockInitializer_RegisterAfterDeleteNotifications_Call { + return &MockInitializer_RegisterAfterDeleteNotifications_Call{Call: _e.mock.On("RegisterAfterDeleteNotifications", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error)) *MockInitializer_RegisterAfterDeleteNotifications_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteNotifications_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error) *MockInitializer_RegisterAfterDeleteNotifications_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error { ret := _m.Called(fn) - var r0 error + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteStorageObjects") + } + + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error); ok { r0 = rf(fn) } else { @@ -301,10 +980,42 @@ func (_m *MockInitializer) RegisterAfterDeleteStorageObjects(fn func(context.Con return r0 } +// MockInitializer_RegisterAfterDeleteStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteStorageObjects' +type MockInitializer_RegisterAfterDeleteStorageObjects_Call struct { + *mock.Call +} + +// RegisterAfterDeleteStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteStorageObjectsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteStorageObjects(fn interface{}) *MockInitializer_RegisterAfterDeleteStorageObjects_Call { + return &MockInitializer_RegisterAfterDeleteStorageObjects_Call{Call: _e.mock.On("RegisterAfterDeleteStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error)) *MockInitializer_RegisterAfterDeleteStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterDeleteStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDeleteTournamentRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDeleteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDeleteTournamentRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error); ok { r0 = rf(fn) @@ -315,10 +1026,42 @@ func (_m *MockInitializer) RegisterAfterDeleteTournamentRecord(fn func(context.C return r0 } +// MockInitializer_RegisterAfterDeleteTournamentRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDeleteTournamentRecord' +type MockInitializer_RegisterAfterDeleteTournamentRecord_Call struct { + *mock.Call +} + +// RegisterAfterDeleteTournamentRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteTournamentRecordRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDeleteTournamentRecord(fn interface{}) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call { + return &MockInitializer_RegisterAfterDeleteTournamentRecord_Call{Call: _e.mock.On("RegisterAfterDeleteTournamentRecord", fn)} +} + +func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error)) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterDemoteGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterDemoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterDemoteGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -329,10 +1072,42 @@ func (_m *MockInitializer) RegisterAfterDemoteGroupUsers(fn func(context.Context return r0 } +// MockInitializer_RegisterAfterDemoteGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterDemoteGroupUsers' +type MockInitializer_RegisterAfterDemoteGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterDemoteGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DemoteGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterDemoteGroupUsers(fn interface{}) *MockInitializer_RegisterAfterDemoteGroupUsers_Call { + return &MockInitializer_RegisterAfterDemoteGroupUsers_Call{Call: _e.mock.On("RegisterAfterDemoteGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error)) *MockInitializer_RegisterAfterDemoteGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterDemoteGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error) *MockInitializer_RegisterAfterDemoteGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterGetAccount provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterGetAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterGetAccount") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error); ok { r0 = rf(fn) @@ -343,10 +1118,88 @@ func (_m *MockInitializer) RegisterAfterGetAccount(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterGetAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterGetAccount' +type MockInitializer_RegisterAfterGetAccount_Call struct { + *mock.Call +} + +// RegisterAfterGetAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Account) error +func (_e *MockInitializer_Expecter) RegisterAfterGetAccount(fn interface{}) *MockInitializer_RegisterAfterGetAccount_Call { + return &MockInitializer_RegisterAfterGetAccount_Call{Call: _e.mock.On("RegisterAfterGetAccount", fn)} +} + +func (_c *MockInitializer_RegisterAfterGetAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error)) *MockInitializer_RegisterAfterGetAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error) *MockInitializer_RegisterAfterGetAccount_Call { + _c.Call.Return(run) + return _c +} + +// RegisterAfterGetMatchmakerStats provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterAfterGetMatchmakerStats(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error { + ret := _m.Called(fn) + + if len(ret) == 0 { + panic("no return value specified for RegisterAfterGetMatchmakerStats") + } + + var r0 error + if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error); ok { + r0 = rf(fn) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockInitializer_RegisterAfterGetMatchmakerStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterGetMatchmakerStats' +type MockInitializer_RegisterAfterGetMatchmakerStats_Call struct { + *mock.Call +} + +// RegisterAfterGetMatchmakerStats is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.MatchmakerStats) error +func (_e *MockInitializer_Expecter) RegisterAfterGetMatchmakerStats(fn interface{}) *MockInitializer_RegisterAfterGetMatchmakerStats_Call { + return &MockInitializer_RegisterAfterGetMatchmakerStats_Call{Call: _e.mock.On("RegisterAfterGetMatchmakerStats", fn)} +} + +func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error)) *MockInitializer_RegisterAfterGetMatchmakerStats_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetMatchmakerStats_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error) *MockInitializer_RegisterAfterGetMatchmakerStats_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterGetSubscription provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterGetSubscription(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterGetSubscription") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error); ok { r0 = rf(fn) @@ -357,10 +1210,42 @@ func (_m *MockInitializer) RegisterAfterGetSubscription(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterGetSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterGetSubscription' +type MockInitializer_RegisterAfterGetSubscription_Call struct { + *mock.Call +} + +// RegisterAfterGetSubscription is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , *api.GetSubscriptionRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterGetSubscription(fn interface{}) *MockInitializer_RegisterAfterGetSubscription_Call { + return &MockInitializer_RegisterAfterGetSubscription_Call{Call: _e.mock.On("RegisterAfterGetSubscription", fn)} +} + +func (_c *MockInitializer_RegisterAfterGetSubscription_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error)) *MockInitializer_RegisterAfterGetSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetSubscription_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetSubscription_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetSubscription_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error) *MockInitializer_RegisterAfterGetSubscription_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterGetUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterGetUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterGetUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error); ok { r0 = rf(fn) @@ -371,10 +1256,42 @@ func (_m *MockInitializer) RegisterAfterGetUsers(fn func(context.Context, runtim return r0 } +// MockInitializer_RegisterAfterGetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterGetUsers' +type MockInitializer_RegisterAfterGetUsers_Call struct { + *mock.Call +} + +// RegisterAfterGetUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Users , *api.GetUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterGetUsers(fn interface{}) *MockInitializer_RegisterAfterGetUsers_Call { + return &MockInitializer_RegisterAfterGetUsers_Call{Call: _e.mock.On("RegisterAfterGetUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterGetUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error)) *MockInitializer_RegisterAfterGetUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterGetUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error) *MockInitializer_RegisterAfterGetUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterImportFacebookFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterImportFacebookFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterImportFacebookFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error); ok { r0 = rf(fn) @@ -385,10 +1302,42 @@ func (_m *MockInitializer) RegisterAfterImportFacebookFriends(fn func(context.Co return r0 } +// MockInitializer_RegisterAfterImportFacebookFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterImportFacebookFriends' +type MockInitializer_RegisterAfterImportFacebookFriends_Call struct { + *mock.Call +} + +// RegisterAfterImportFacebookFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportFacebookFriendsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterImportFacebookFriends(fn interface{}) *MockInitializer_RegisterAfterImportFacebookFriends_Call { + return &MockInitializer_RegisterAfterImportFacebookFriends_Call{Call: _e.mock.On("RegisterAfterImportFacebookFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error)) *MockInitializer_RegisterAfterImportFacebookFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterImportFacebookFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error) *MockInitializer_RegisterAfterImportFacebookFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterImportSteamFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterImportSteamFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterImportSteamFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error); ok { r0 = rf(fn) @@ -399,10 +1348,42 @@ func (_m *MockInitializer) RegisterAfterImportSteamFriends(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterImportSteamFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterImportSteamFriends' +type MockInitializer_RegisterAfterImportSteamFriends_Call struct { + *mock.Call +} + +// RegisterAfterImportSteamFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportSteamFriendsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterImportSteamFriends(fn interface{}) *MockInitializer_RegisterAfterImportSteamFriends_Call { + return &MockInitializer_RegisterAfterImportSteamFriends_Call{Call: _e.mock.On("RegisterAfterImportSteamFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error)) *MockInitializer_RegisterAfterImportSteamFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterImportSteamFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error) *MockInitializer_RegisterAfterImportSteamFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterJoinGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterJoinGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterJoinGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error); ok { r0 = rf(fn) @@ -413,10 +1394,42 @@ func (_m *MockInitializer) RegisterAfterJoinGroup(fn func(context.Context, runti return r0 } +// MockInitializer_RegisterAfterJoinGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterJoinGroup' +type MockInitializer_RegisterAfterJoinGroup_Call struct { + *mock.Call +} + +// RegisterAfterJoinGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinGroupRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterJoinGroup(fn interface{}) *MockInitializer_RegisterAfterJoinGroup_Call { + return &MockInitializer_RegisterAfterJoinGroup_Call{Call: _e.mock.On("RegisterAfterJoinGroup", fn)} +} + +func (_c *MockInitializer_RegisterAfterJoinGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error)) *MockInitializer_RegisterAfterJoinGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterJoinGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterJoinGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterJoinGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error) *MockInitializer_RegisterAfterJoinGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterJoinTournament provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterJoinTournament(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterJoinTournament") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error); ok { r0 = rf(fn) @@ -427,10 +1440,42 @@ func (_m *MockInitializer) RegisterAfterJoinTournament(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterJoinTournament_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterJoinTournament' +type MockInitializer_RegisterAfterJoinTournament_Call struct { + *mock.Call +} + +// RegisterAfterJoinTournament is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinTournamentRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterJoinTournament(fn interface{}) *MockInitializer_RegisterAfterJoinTournament_Call { + return &MockInitializer_RegisterAfterJoinTournament_Call{Call: _e.mock.On("RegisterAfterJoinTournament", fn)} +} + +func (_c *MockInitializer_RegisterAfterJoinTournament_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error)) *MockInitializer_RegisterAfterJoinTournament_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterJoinTournament_Call) Return(_a0 error) *MockInitializer_RegisterAfterJoinTournament_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterJoinTournament_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error) *MockInitializer_RegisterAfterJoinTournament_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterKickGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterKickGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterKickGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -441,10 +1486,42 @@ func (_m *MockInitializer) RegisterAfterKickGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterKickGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterKickGroupUsers' +type MockInitializer_RegisterAfterKickGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterKickGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.KickGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterKickGroupUsers(fn interface{}) *MockInitializer_RegisterAfterKickGroupUsers_Call { + return &MockInitializer_RegisterAfterKickGroupUsers_Call{Call: _e.mock.On("RegisterAfterKickGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error)) *MockInitializer_RegisterAfterKickGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterKickGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error) *MockInitializer_RegisterAfterKickGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLeaveGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLeaveGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLeaveGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error); ok { r0 = rf(fn) @@ -455,10 +1532,42 @@ func (_m *MockInitializer) RegisterAfterLeaveGroup(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterLeaveGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLeaveGroup' +type MockInitializer_RegisterAfterLeaveGroup_Call struct { + *mock.Call +} + +// RegisterAfterLeaveGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaveGroupRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterLeaveGroup(fn interface{}) *MockInitializer_RegisterAfterLeaveGroup_Call { + return &MockInitializer_RegisterAfterLeaveGroup_Call{Call: _e.mock.On("RegisterAfterLeaveGroup", fn)} +} + +func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error)) *MockInitializer_RegisterAfterLeaveGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterLeaveGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error) *MockInitializer_RegisterAfterLeaveGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error); ok { r0 = rf(fn) @@ -469,10 +1578,42 @@ func (_m *MockInitializer) RegisterAfterLinkApple(fn func(context.Context, runti return r0 } +// MockInitializer_RegisterAfterLinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkApple' +type MockInitializer_RegisterAfterLinkApple_Call struct { + *mock.Call +} + +// RegisterAfterLinkApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkApple(fn interface{}) *MockInitializer_RegisterAfterLinkApple_Call { + return &MockInitializer_RegisterAfterLinkApple_Call{Call: _e.mock.On("RegisterAfterLinkApple", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) *MockInitializer_RegisterAfterLinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error) *MockInitializer_RegisterAfterLinkApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error); ok { r0 = rf(fn) @@ -483,10 +1624,42 @@ func (_m *MockInitializer) RegisterAfterLinkCustom(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterLinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkCustom' +type MockInitializer_RegisterAfterLinkCustom_Call struct { + *mock.Call +} + +// RegisterAfterLinkCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkCustom(fn interface{}) *MockInitializer_RegisterAfterLinkCustom_Call { + return &MockInitializer_RegisterAfterLinkCustom_Call{Call: _e.mock.On("RegisterAfterLinkCustom", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) *MockInitializer_RegisterAfterLinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error) *MockInitializer_RegisterAfterLinkCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error); ok { r0 = rf(fn) @@ -497,10 +1670,42 @@ func (_m *MockInitializer) RegisterAfterLinkDevice(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterLinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkDevice' +type MockInitializer_RegisterAfterLinkDevice_Call struct { + *mock.Call +} + +// RegisterAfterLinkDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkDevice(fn interface{}) *MockInitializer_RegisterAfterLinkDevice_Call { + return &MockInitializer_RegisterAfterLinkDevice_Call{Call: _e.mock.On("RegisterAfterLinkDevice", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) *MockInitializer_RegisterAfterLinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error) *MockInitializer_RegisterAfterLinkDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error); ok { r0 = rf(fn) @@ -511,10 +1716,42 @@ func (_m *MockInitializer) RegisterAfterLinkEmail(fn func(context.Context, runti return r0 } +// MockInitializer_RegisterAfterLinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkEmail' +type MockInitializer_RegisterAfterLinkEmail_Call struct { + *mock.Call +} + +// RegisterAfterLinkEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkEmail(fn interface{}) *MockInitializer_RegisterAfterLinkEmail_Call { + return &MockInitializer_RegisterAfterLinkEmail_Call{Call: _e.mock.On("RegisterAfterLinkEmail", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) *MockInitializer_RegisterAfterLinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error) *MockInitializer_RegisterAfterLinkEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error); ok { r0 = rf(fn) @@ -525,10 +1762,42 @@ func (_m *MockInitializer) RegisterAfterLinkFacebook(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterAfterLinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkFacebook' +type MockInitializer_RegisterAfterLinkFacebook_Call struct { + *mock.Call +} + +// RegisterAfterLinkFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkFacebookRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkFacebook(fn interface{}) *MockInitializer_RegisterAfterLinkFacebook_Call { + return &MockInitializer_RegisterAfterLinkFacebook_Call{Call: _e.mock.On("RegisterAfterLinkFacebook", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error)) *MockInitializer_RegisterAfterLinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error) *MockInitializer_RegisterAfterLinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error); ok { r0 = rf(fn) @@ -539,10 +1808,42 @@ func (_m *MockInitializer) RegisterAfterLinkFacebookInstantGame(fn func(context. return r0 } +// MockInitializer_RegisterAfterLinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkFacebookInstantGame' +type MockInitializer_RegisterAfterLinkFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterAfterLinkFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call { + return &MockInitializer_RegisterAfterLinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterLinkFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error); ok { r0 = rf(fn) @@ -553,10 +1854,42 @@ func (_m *MockInitializer) RegisterAfterLinkGameCenter(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterLinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkGameCenter' +type MockInitializer_RegisterAfterLinkGameCenter_Call struct { + *mock.Call +} + +// RegisterAfterLinkGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkGameCenter(fn interface{}) *MockInitializer_RegisterAfterLinkGameCenter_Call { + return &MockInitializer_RegisterAfterLinkGameCenter_Call{Call: _e.mock.On("RegisterAfterLinkGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) *MockInitializer_RegisterAfterLinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error) *MockInitializer_RegisterAfterLinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterLinkGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterLinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error); ok { r0 = rf(fn) @@ -567,10 +1900,42 @@ func (_m *MockInitializer) RegisterAfterLinkGoogle(fn func(context.Context, runt return r0 } -// RegisterAfterLinkSteam provides a mock function with given fields: fn -func (_m *MockInitializer) RegisterAfterLinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error { +// MockInitializer_RegisterAfterLinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkGoogle' +type MockInitializer_RegisterAfterLinkGoogle_Call struct { + *mock.Call +} + +// RegisterAfterLinkGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkGoogle(fn interface{}) *MockInitializer_RegisterAfterLinkGoogle_Call { + return &MockInitializer_RegisterAfterLinkGoogle_Call{Call: _e.mock.On("RegisterAfterLinkGoogle", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) *MockInitializer_RegisterAfterLinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error) *MockInitializer_RegisterAfterLinkGoogle_Call { + _c.Call.Return(run) + return _c +} + +// RegisterAfterLinkSteam provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterAfterLinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterLinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error); ok { r0 = rf(fn) @@ -581,10 +1946,42 @@ func (_m *MockInitializer) RegisterAfterLinkSteam(fn func(context.Context, runti return r0 } +// MockInitializer_RegisterAfterLinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterLinkSteam' +type MockInitializer_RegisterAfterLinkSteam_Call struct { + *mock.Call +} + +// RegisterAfterLinkSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkSteamRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterLinkSteam(fn interface{}) *MockInitializer_RegisterAfterLinkSteam_Call { + return &MockInitializer_RegisterAfterLinkSteam_Call{Call: _e.mock.On("RegisterAfterLinkSteam", fn)} +} + +func (_c *MockInitializer_RegisterAfterLinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error)) *MockInitializer_RegisterAfterLinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterLinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error) *MockInitializer_RegisterAfterLinkSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListChannelMessages provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListChannelMessages(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListChannelMessages") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error); ok { r0 = rf(fn) @@ -595,10 +1992,42 @@ func (_m *MockInitializer) RegisterAfterListChannelMessages(fn func(context.Cont return r0 } +// MockInitializer_RegisterAfterListChannelMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListChannelMessages' +type MockInitializer_RegisterAfterListChannelMessages_Call struct { + *mock.Call +} + +// RegisterAfterListChannelMessages is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ChannelMessageList , *api.ListChannelMessagesRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListChannelMessages(fn interface{}) *MockInitializer_RegisterAfterListChannelMessages_Call { + return &MockInitializer_RegisterAfterListChannelMessages_Call{Call: _e.mock.On("RegisterAfterListChannelMessages", fn)} +} + +func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error)) *MockInitializer_RegisterAfterListChannelMessages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) Return(_a0 error) *MockInitializer_RegisterAfterListChannelMessages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error) *MockInitializer_RegisterAfterListChannelMessages_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error); ok { r0 = rf(fn) @@ -609,10 +2038,42 @@ func (_m *MockInitializer) RegisterAfterListFriends(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterListFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListFriends' +type MockInitializer_RegisterAfterListFriends_Call struct { + *mock.Call +} + +// RegisterAfterListFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.FriendList) error +func (_e *MockInitializer_Expecter) RegisterAfterListFriends(fn interface{}) *MockInitializer_RegisterAfterListFriends_Call { + return &MockInitializer_RegisterAfterListFriends_Call{Call: _e.mock.On("RegisterAfterListFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterListFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error)) *MockInitializer_RegisterAfterListFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterListFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error) *MockInitializer_RegisterAfterListFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListFriendsOfFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListFriendsOfFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListFriendsOfFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error); ok { r0 = rf(fn) @@ -623,10 +2084,42 @@ func (_m *MockInitializer) RegisterAfterListFriendsOfFriends(fn func(context.Con return r0 } +// MockInitializer_RegisterAfterListFriendsOfFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListFriendsOfFriends' +type MockInitializer_RegisterAfterListFriendsOfFriends_Call struct { + *mock.Call +} + +// RegisterAfterListFriendsOfFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.FriendsOfFriendsList) error +func (_e *MockInitializer_Expecter) RegisterAfterListFriendsOfFriends(fn interface{}) *MockInitializer_RegisterAfterListFriendsOfFriends_Call { + return &MockInitializer_RegisterAfterListFriendsOfFriends_Call{Call: _e.mock.On("RegisterAfterListFriendsOfFriends", fn)} +} + +func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error)) *MockInitializer_RegisterAfterListFriendsOfFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterListFriendsOfFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error) *MockInitializer_RegisterAfterListFriendsOfFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -637,10 +2130,42 @@ func (_m *MockInitializer) RegisterAfterListGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterListGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListGroupUsers' +type MockInitializer_RegisterAfterListGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterListGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GroupUserList , *api.ListGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListGroupUsers(fn interface{}) *MockInitializer_RegisterAfterListGroupUsers_Call { + return &MockInitializer_RegisterAfterListGroupUsers_Call{Call: _e.mock.On("RegisterAfterListGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error)) *MockInitializer_RegisterAfterListGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterListGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error) *MockInitializer_RegisterAfterListGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListGroups provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListGroups") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error); ok { r0 = rf(fn) @@ -651,10 +2176,42 @@ func (_m *MockInitializer) RegisterAfterListGroups(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterAfterListGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListGroups' +type MockInitializer_RegisterAfterListGroups_Call struct { + *mock.Call +} + +// RegisterAfterListGroups is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GroupList , *api.ListGroupsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListGroups(fn interface{}) *MockInitializer_RegisterAfterListGroups_Call { + return &MockInitializer_RegisterAfterListGroups_Call{Call: _e.mock.On("RegisterAfterListGroups", fn)} +} + +func (_c *MockInitializer_RegisterAfterListGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error)) *MockInitializer_RegisterAfterListGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListGroups_Call) Return(_a0 error) *MockInitializer_RegisterAfterListGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error) *MockInitializer_RegisterAfterListGroups_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListLeaderboardRecords provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListLeaderboardRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListLeaderboardRecords") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error); ok { r0 = rf(fn) @@ -665,10 +2222,42 @@ func (_m *MockInitializer) RegisterAfterListLeaderboardRecords(fn func(context.C return r0 } +// MockInitializer_RegisterAfterListLeaderboardRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListLeaderboardRecords' +type MockInitializer_RegisterAfterListLeaderboardRecords_Call struct { + *mock.Call +} + +// RegisterAfterListLeaderboardRecords is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecordList , *api.ListLeaderboardRecordsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListLeaderboardRecords(fn interface{}) *MockInitializer_RegisterAfterListLeaderboardRecords_Call { + return &MockInitializer_RegisterAfterListLeaderboardRecords_Call{Call: _e.mock.On("RegisterAfterListLeaderboardRecords", fn)} +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error)) *MockInitializer_RegisterAfterListLeaderboardRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) Return(_a0 error) *MockInitializer_RegisterAfterListLeaderboardRecords_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error) *MockInitializer_RegisterAfterListLeaderboardRecords_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListLeaderboardRecordsAroundOwner provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListLeaderboardRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListLeaderboardRecordsAroundOwner") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error); ok { r0 = rf(fn) @@ -679,10 +2268,42 @@ func (_m *MockInitializer) RegisterAfterListLeaderboardRecordsAroundOwner(fn fun return r0 } +// MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListLeaderboardRecordsAroundOwner' +type MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call struct { + *mock.Call +} + +// RegisterAfterListLeaderboardRecordsAroundOwner is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecordList , *api.ListLeaderboardRecordsAroundOwnerRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListLeaderboardRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call { + return &MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call{Call: _e.mock.On("RegisterAfterListLeaderboardRecordsAroundOwner", fn)} +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error)) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListMatches provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListMatches(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListMatches") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error); ok { r0 = rf(fn) @@ -693,10 +2314,42 @@ func (_m *MockInitializer) RegisterAfterListMatches(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterListMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListMatches' +type MockInitializer_RegisterAfterListMatches_Call struct { + *mock.Call +} + +// RegisterAfterListMatches is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.MatchList , *api.ListMatchesRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListMatches(fn interface{}) *MockInitializer_RegisterAfterListMatches_Call { + return &MockInitializer_RegisterAfterListMatches_Call{Call: _e.mock.On("RegisterAfterListMatches", fn)} +} + +func (_c *MockInitializer_RegisterAfterListMatches_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error)) *MockInitializer_RegisterAfterListMatches_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListMatches_Call) Return(_a0 error) *MockInitializer_RegisterAfterListMatches_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListMatches_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error) *MockInitializer_RegisterAfterListMatches_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListNotifications provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListNotifications") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error); ok { r0 = rf(fn) @@ -707,10 +2360,42 @@ func (_m *MockInitializer) RegisterAfterListNotifications(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterListNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListNotifications' +type MockInitializer_RegisterAfterListNotifications_Call struct { + *mock.Call +} + +// RegisterAfterListNotifications is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.NotificationList , *api.ListNotificationsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListNotifications(fn interface{}) *MockInitializer_RegisterAfterListNotifications_Call { + return &MockInitializer_RegisterAfterListNotifications_Call{Call: _e.mock.On("RegisterAfterListNotifications", fn)} +} + +func (_c *MockInitializer_RegisterAfterListNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error)) *MockInitializer_RegisterAfterListNotifications_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListNotifications_Call) Return(_a0 error) *MockInitializer_RegisterAfterListNotifications_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error) *MockInitializer_RegisterAfterListNotifications_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error); ok { r0 = rf(fn) @@ -721,10 +2406,42 @@ func (_m *MockInitializer) RegisterAfterListStorageObjects(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterListStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListStorageObjects' +type MockInitializer_RegisterAfterListStorageObjects_Call struct { + *mock.Call +} + +// RegisterAfterListStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjectList , *api.ListStorageObjectsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListStorageObjects(fn interface{}) *MockInitializer_RegisterAfterListStorageObjects_Call { + return &MockInitializer_RegisterAfterListStorageObjects_Call{Call: _e.mock.On("RegisterAfterListStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error)) *MockInitializer_RegisterAfterListStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterListStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterListStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListSubscriptions provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListSubscriptions(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListSubscriptions") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error); ok { r0 = rf(fn) @@ -735,10 +2452,42 @@ func (_m *MockInitializer) RegisterAfterListSubscriptions(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterListSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListSubscriptions' +type MockInitializer_RegisterAfterListSubscriptions_Call struct { + *mock.Call +} + +// RegisterAfterListSubscriptions is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SubscriptionList , *api.ListSubscriptionsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListSubscriptions(fn interface{}) *MockInitializer_RegisterAfterListSubscriptions_Call { + return &MockInitializer_RegisterAfterListSubscriptions_Call{Call: _e.mock.On("RegisterAfterListSubscriptions", fn)} +} + +func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error)) *MockInitializer_RegisterAfterListSubscriptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) Return(_a0 error) *MockInitializer_RegisterAfterListSubscriptions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error) *MockInitializer_RegisterAfterListSubscriptions_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListTournamentRecords provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListTournamentRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListTournamentRecords") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error); ok { r0 = rf(fn) @@ -749,10 +2498,42 @@ func (_m *MockInitializer) RegisterAfterListTournamentRecords(fn func(context.Co return r0 } +// MockInitializer_RegisterAfterListTournamentRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListTournamentRecords' +type MockInitializer_RegisterAfterListTournamentRecords_Call struct { + *mock.Call +} + +// RegisterAfterListTournamentRecords is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentRecordList , *api.ListTournamentRecordsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListTournamentRecords(fn interface{}) *MockInitializer_RegisterAfterListTournamentRecords_Call { + return &MockInitializer_RegisterAfterListTournamentRecords_Call{Call: _e.mock.On("RegisterAfterListTournamentRecords", fn)} +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error)) *MockInitializer_RegisterAfterListTournamentRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournamentRecords_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error) *MockInitializer_RegisterAfterListTournamentRecords_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListTournamentRecordsAroundOwner provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListTournamentRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListTournamentRecordsAroundOwner") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error); ok { r0 = rf(fn) @@ -763,10 +2544,42 @@ func (_m *MockInitializer) RegisterAfterListTournamentRecordsAroundOwner(fn func return r0 } +// MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListTournamentRecordsAroundOwner' +type MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call struct { + *mock.Call +} + +// RegisterAfterListTournamentRecordsAroundOwner is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentRecordList , *api.ListTournamentRecordsAroundOwnerRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListTournamentRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call { + return &MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call{Call: _e.mock.On("RegisterAfterListTournamentRecordsAroundOwner", fn)} +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error)) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListTournaments provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListTournaments(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListTournaments") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error); ok { r0 = rf(fn) @@ -777,10 +2590,42 @@ func (_m *MockInitializer) RegisterAfterListTournaments(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterListTournaments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListTournaments' +type MockInitializer_RegisterAfterListTournaments_Call struct { + *mock.Call +} + +// RegisterAfterListTournaments is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentList , *api.ListTournamentsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListTournaments(fn interface{}) *MockInitializer_RegisterAfterListTournaments_Call { + return &MockInitializer_RegisterAfterListTournaments_Call{Call: _e.mock.On("RegisterAfterListTournaments", fn)} +} + +func (_c *MockInitializer_RegisterAfterListTournaments_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error)) *MockInitializer_RegisterAfterListTournaments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournaments_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournaments_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListTournaments_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error) *MockInitializer_RegisterAfterListTournaments_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterListUserGroups provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterListUserGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterListUserGroups") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error); ok { r0 = rf(fn) @@ -791,10 +2636,42 @@ func (_m *MockInitializer) RegisterAfterListUserGroups(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterListUserGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterListUserGroups' +type MockInitializer_RegisterAfterListUserGroups_Call struct { + *mock.Call +} + +// RegisterAfterListUserGroups is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UserGroupList , *api.ListUserGroupsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterListUserGroups(fn interface{}) *MockInitializer_RegisterAfterListUserGroups_Call { + return &MockInitializer_RegisterAfterListUserGroups_Call{Call: _e.mock.On("RegisterAfterListUserGroups", fn)} +} + +func (_c *MockInitializer_RegisterAfterListUserGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error)) *MockInitializer_RegisterAfterListUserGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterListUserGroups_Call) Return(_a0 error) *MockInitializer_RegisterAfterListUserGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterListUserGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error) *MockInitializer_RegisterAfterListUserGroups_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterPromoteGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterPromoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterPromoteGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error); ok { r0 = rf(fn) @@ -805,10 +2682,42 @@ func (_m *MockInitializer) RegisterAfterPromoteGroupUsers(fn func(context.Contex return r0 } +// MockInitializer_RegisterAfterPromoteGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterPromoteGroupUsers' +type MockInitializer_RegisterAfterPromoteGroupUsers_Call struct { + *mock.Call +} + +// RegisterAfterPromoteGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.PromoteGroupUsersRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterPromoteGroupUsers(fn interface{}) *MockInitializer_RegisterAfterPromoteGroupUsers_Call { + return &MockInitializer_RegisterAfterPromoteGroupUsers_Call{Call: _e.mock.On("RegisterAfterPromoteGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error)) *MockInitializer_RegisterAfterPromoteGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterPromoteGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error) *MockInitializer_RegisterAfterPromoteGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterReadStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterReadStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterReadStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error); ok { r0 = rf(fn) @@ -819,10 +2728,42 @@ func (_m *MockInitializer) RegisterAfterReadStorageObjects(fn func(context.Conte return r0 } +// MockInitializer_RegisterAfterReadStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterReadStorageObjects' +type MockInitializer_RegisterAfterReadStorageObjects_Call struct { + *mock.Call +} + +// RegisterAfterReadStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjects , *api.ReadStorageObjectsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterReadStorageObjects(fn interface{}) *MockInitializer_RegisterAfterReadStorageObjects_Call { + return &MockInitializer_RegisterAfterReadStorageObjects_Call{Call: _e.mock.On("RegisterAfterReadStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error)) *MockInitializer_RegisterAfterReadStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterReadStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterReadStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterRt provides a mock function with given fields: id, fn func (_m *MockInitializer) RegisterAfterRt(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error { ret := _m.Called(id, fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterRt") + } + var r0 error if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error); ok { r0 = rf(id, fn) @@ -833,10 +2774,43 @@ func (_m *MockInitializer) RegisterAfterRt(id string, fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterRt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterRt' +type MockInitializer_RegisterAfterRt_Call struct { + *mock.Call +} + +// RegisterAfterRt is a helper method to define mock.On call +// - id string +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *rtapi.Envelope , *rtapi.Envelope) error +func (_e *MockInitializer_Expecter) RegisterAfterRt(id interface{}, fn interface{}) *MockInitializer_RegisterAfterRt_Call { + return &MockInitializer_RegisterAfterRt_Call{Call: _e.mock.On("RegisterAfterRt", id, fn)} +} + +func (_c *MockInitializer_RegisterAfterRt_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error)) *MockInitializer_RegisterAfterRt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterRt_Call) Return(_a0 error) *MockInitializer_RegisterAfterRt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterRt_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error) *MockInitializer_RegisterAfterRt_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterSessionLogout provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterSessionLogout(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterSessionLogout") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error); ok { r0 = rf(fn) @@ -847,10 +2821,42 @@ func (_m *MockInitializer) RegisterAfterSessionLogout(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterSessionLogout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterSessionLogout' +type MockInitializer_RegisterAfterSessionLogout_Call struct { + *mock.Call +} + +// RegisterAfterSessionLogout is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionLogoutRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterSessionLogout(fn interface{}) *MockInitializer_RegisterAfterSessionLogout_Call { + return &MockInitializer_RegisterAfterSessionLogout_Call{Call: _e.mock.On("RegisterAfterSessionLogout", fn)} +} + +func (_c *MockInitializer_RegisterAfterSessionLogout_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error)) *MockInitializer_RegisterAfterSessionLogout_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterSessionLogout_Call) Return(_a0 error) *MockInitializer_RegisterAfterSessionLogout_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterSessionLogout_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error) *MockInitializer_RegisterAfterSessionLogout_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterSessionRefresh provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterSessionRefresh(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterSessionRefresh") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error); ok { r0 = rf(fn) @@ -861,10 +2867,42 @@ func (_m *MockInitializer) RegisterAfterSessionRefresh(fn func(context.Context, return r0 } -// RegisterAfterUnlinkApple provides a mock function with given fields: fn -func (_m *MockInitializer) RegisterAfterUnlinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error { +// MockInitializer_RegisterAfterSessionRefresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterSessionRefresh' +type MockInitializer_RegisterAfterSessionRefresh_Call struct { + *mock.Call +} + +// RegisterAfterSessionRefresh is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.SessionRefreshRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterSessionRefresh(fn interface{}) *MockInitializer_RegisterAfterSessionRefresh_Call { + return &MockInitializer_RegisterAfterSessionRefresh_Call{Call: _e.mock.On("RegisterAfterSessionRefresh", fn)} +} + +func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error)) *MockInitializer_RegisterAfterSessionRefresh_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) Return(_a0 error) *MockInitializer_RegisterAfterSessionRefresh_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error) *MockInitializer_RegisterAfterSessionRefresh_Call { + _c.Call.Return(run) + return _c +} + +// RegisterAfterUnlinkApple provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterAfterUnlinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error); ok { r0 = rf(fn) @@ -875,10 +2913,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkApple(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterUnlinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkApple' +type MockInitializer_RegisterAfterUnlinkApple_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkApple(fn interface{}) *MockInitializer_RegisterAfterUnlinkApple_Call { + return &MockInitializer_RegisterAfterUnlinkApple_Call{Call: _e.mock.On("RegisterAfterUnlinkApple", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) *MockInitializer_RegisterAfterUnlinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error) *MockInitializer_RegisterAfterUnlinkApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error); ok { r0 = rf(fn) @@ -889,10 +2959,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkCustom(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterAfterUnlinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkCustom' +type MockInitializer_RegisterAfterUnlinkCustom_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkCustom(fn interface{}) *MockInitializer_RegisterAfterUnlinkCustom_Call { + return &MockInitializer_RegisterAfterUnlinkCustom_Call{Call: _e.mock.On("RegisterAfterUnlinkCustom", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) *MockInitializer_RegisterAfterUnlinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error) *MockInitializer_RegisterAfterUnlinkCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error); ok { r0 = rf(fn) @@ -903,10 +3005,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkDevice(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterAfterUnlinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkDevice' +type MockInitializer_RegisterAfterUnlinkDevice_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkDevice(fn interface{}) *MockInitializer_RegisterAfterUnlinkDevice_Call { + return &MockInitializer_RegisterAfterUnlinkDevice_Call{Call: _e.mock.On("RegisterAfterUnlinkDevice", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) *MockInitializer_RegisterAfterUnlinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error) *MockInitializer_RegisterAfterUnlinkDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error); ok { r0 = rf(fn) @@ -917,10 +3051,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkEmail(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterUnlinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkEmail' +type MockInitializer_RegisterAfterUnlinkEmail_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkEmail(fn interface{}) *MockInitializer_RegisterAfterUnlinkEmail_Call { + return &MockInitializer_RegisterAfterUnlinkEmail_Call{Call: _e.mock.On("RegisterAfterUnlinkEmail", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) *MockInitializer_RegisterAfterUnlinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error) *MockInitializer_RegisterAfterUnlinkEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error); ok { r0 = rf(fn) @@ -931,10 +3097,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkFacebook(fn func(context.Context, return r0 } +// MockInitializer_RegisterAfterUnlinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkFacebook' +type MockInitializer_RegisterAfterUnlinkFacebook_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebook) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkFacebook(fn interface{}) *MockInitializer_RegisterAfterUnlinkFacebook_Call { + return &MockInitializer_RegisterAfterUnlinkFacebook_Call{Call: _e.mock.On("RegisterAfterUnlinkFacebook", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error)) *MockInitializer_RegisterAfterUnlinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error) *MockInitializer_RegisterAfterUnlinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error); ok { r0 = rf(fn) @@ -945,10 +3143,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkFacebookInstantGame(fn func(contex return r0 } +// MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkFacebookInstantGame' +type MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call { + return &MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterUnlinkFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error); ok { r0 = rf(fn) @@ -959,10 +3189,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkGameCenter(fn func(context.Context return r0 } +// MockInitializer_RegisterAfterUnlinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkGameCenter' +type MockInitializer_RegisterAfterUnlinkGameCenter_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkGameCenter(fn interface{}) *MockInitializer_RegisterAfterUnlinkGameCenter_Call { + return &MockInitializer_RegisterAfterUnlinkGameCenter_Call{Call: _e.mock.On("RegisterAfterUnlinkGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) *MockInitializer_RegisterAfterUnlinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error) *MockInitializer_RegisterAfterUnlinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error); ok { r0 = rf(fn) @@ -973,10 +3235,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkGoogle(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterAfterUnlinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkGoogle' +type MockInitializer_RegisterAfterUnlinkGoogle_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkGoogle(fn interface{}) *MockInitializer_RegisterAfterUnlinkGoogle_Call { + return &MockInitializer_RegisterAfterUnlinkGoogle_Call{Call: _e.mock.On("RegisterAfterUnlinkGoogle", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) *MockInitializer_RegisterAfterUnlinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error) *MockInitializer_RegisterAfterUnlinkGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUnlinkSteam provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUnlinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUnlinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error); ok { r0 = rf(fn) @@ -987,10 +3281,42 @@ func (_m *MockInitializer) RegisterAfterUnlinkSteam(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterUnlinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUnlinkSteam' +type MockInitializer_RegisterAfterUnlinkSteam_Call struct { + *mock.Call +} + +// RegisterAfterUnlinkSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountSteam) error +func (_e *MockInitializer_Expecter) RegisterAfterUnlinkSteam(fn interface{}) *MockInitializer_RegisterAfterUnlinkSteam_Call { + return &MockInitializer_RegisterAfterUnlinkSteam_Call{Call: _e.mock.On("RegisterAfterUnlinkSteam", fn)} +} + +func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error)) *MockInitializer_RegisterAfterUnlinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error) *MockInitializer_RegisterAfterUnlinkSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUpdateAccount provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUpdateAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUpdateAccount") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error); ok { r0 = rf(fn) @@ -1001,10 +3327,42 @@ func (_m *MockInitializer) RegisterAfterUpdateAccount(fn func(context.Context, r return r0 } +// MockInitializer_RegisterAfterUpdateAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUpdateAccount' +type MockInitializer_RegisterAfterUpdateAccount_Call struct { + *mock.Call +} + +// RegisterAfterUpdateAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateAccountRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterUpdateAccount(fn interface{}) *MockInitializer_RegisterAfterUpdateAccount_Call { + return &MockInitializer_RegisterAfterUpdateAccount_Call{Call: _e.mock.On("RegisterAfterUpdateAccount", fn)} +} + +func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error)) *MockInitializer_RegisterAfterUpdateAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterUpdateAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error) *MockInitializer_RegisterAfterUpdateAccount_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterUpdateGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterUpdateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterUpdateGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error); ok { r0 = rf(fn) @@ -1015,10 +3373,42 @@ func (_m *MockInitializer) RegisterAfterUpdateGroup(fn func(context.Context, run return r0 } +// MockInitializer_RegisterAfterUpdateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterUpdateGroup' +type MockInitializer_RegisterAfterUpdateGroup_Call struct { + *mock.Call +} + +// RegisterAfterUpdateGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateGroupRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterUpdateGroup(fn interface{}) *MockInitializer_RegisterAfterUpdateGroup_Call { + return &MockInitializer_RegisterAfterUpdateGroup_Call{Call: _e.mock.On("RegisterAfterUpdateGroup", fn)} +} + +func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error)) *MockInitializer_RegisterAfterUpdateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterUpdateGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error) *MockInitializer_RegisterAfterUpdateGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidatePurchaseApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidatePurchaseApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidatePurchaseApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error); ok { r0 = rf(fn) @@ -1029,10 +3419,42 @@ func (_m *MockInitializer) RegisterAfterValidatePurchaseApple(fn func(context.Co return r0 } +// MockInitializer_RegisterAfterValidatePurchaseApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidatePurchaseApple' +type MockInitializer_RegisterAfterValidatePurchaseApple_Call struct { + *mock.Call +} + +// RegisterAfterValidatePurchaseApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseAppleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseApple(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseApple_Call { + return &MockInitializer_RegisterAfterValidatePurchaseApple_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseApple", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidatePurchaseFacebookInstant provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidatePurchaseFacebookInstant(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidatePurchaseFacebookInstant") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error); ok { r0 = rf(fn) @@ -1043,10 +3465,42 @@ func (_m *MockInitializer) RegisterAfterValidatePurchaseFacebookInstant(fn func( return r0 } +// MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidatePurchaseFacebookInstant' +type MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call struct { + *mock.Call +} + +// RegisterAfterValidatePurchaseFacebookInstant is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseFacebookInstantRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseFacebookInstant(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call { + return &MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseFacebookInstant", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidatePurchaseGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidatePurchaseGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidatePurchaseGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error); ok { r0 = rf(fn) @@ -1057,10 +3511,42 @@ func (_m *MockInitializer) RegisterAfterValidatePurchaseGoogle(fn func(context.C return r0 } +// MockInitializer_RegisterAfterValidatePurchaseGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidatePurchaseGoogle' +type MockInitializer_RegisterAfterValidatePurchaseGoogle_Call struct { + *mock.Call +} + +// RegisterAfterValidatePurchaseGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseGoogleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseGoogle(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call { + return &MockInitializer_RegisterAfterValidatePurchaseGoogle_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseGoogle", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidatePurchaseHuawei provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidatePurchaseHuawei(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidatePurchaseHuawei") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error); ok { r0 = rf(fn) @@ -1071,10 +3557,42 @@ func (_m *MockInitializer) RegisterAfterValidatePurchaseHuawei(fn func(context.C return r0 } +// MockInitializer_RegisterAfterValidatePurchaseHuawei_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidatePurchaseHuawei' +type MockInitializer_RegisterAfterValidatePurchaseHuawei_Call struct { + *mock.Call +} + +// RegisterAfterValidatePurchaseHuawei is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseHuaweiRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseHuawei(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call { + return &MockInitializer_RegisterAfterValidatePurchaseHuawei_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseHuawei", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidateSubscriptionApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidateSubscriptionApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidateSubscriptionApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error); ok { r0 = rf(fn) @@ -1085,10 +3603,42 @@ func (_m *MockInitializer) RegisterAfterValidateSubscriptionApple(fn func(contex return r0 } +// MockInitializer_RegisterAfterValidateSubscriptionApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidateSubscriptionApple' +type MockInitializer_RegisterAfterValidateSubscriptionApple_Call struct { + *mock.Call +} + +// RegisterAfterValidateSubscriptionApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionResponse , *api.ValidateSubscriptionAppleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidateSubscriptionApple(fn interface{}) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call { + return &MockInitializer_RegisterAfterValidateSubscriptionApple_Call{Call: _e.mock.On("RegisterAfterValidateSubscriptionApple", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error)) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterValidateSubscriptionGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterValidateSubscriptionGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterValidateSubscriptionGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error); ok { r0 = rf(fn) @@ -1099,10 +3649,42 @@ func (_m *MockInitializer) RegisterAfterValidateSubscriptionGoogle(fn func(conte return r0 } +// MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterValidateSubscriptionGoogle' +type MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call struct { + *mock.Call +} + +// RegisterAfterValidateSubscriptionGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionResponse , *api.ValidateSubscriptionGoogleRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterValidateSubscriptionGoogle(fn interface{}) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call { + return &MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call{Call: _e.mock.On("RegisterAfterValidateSubscriptionGoogle", fn)} +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error)) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterWriteLeaderboardRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterWriteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterWriteLeaderboardRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error); ok { r0 = rf(fn) @@ -1113,10 +3695,42 @@ func (_m *MockInitializer) RegisterAfterWriteLeaderboardRecord(fn func(context.C return r0 } +// MockInitializer_RegisterAfterWriteLeaderboardRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterWriteLeaderboardRecord' +type MockInitializer_RegisterAfterWriteLeaderboardRecord_Call struct { + *mock.Call +} + +// RegisterAfterWriteLeaderboardRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecord , *api.WriteLeaderboardRecordRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterWriteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call { + return &MockInitializer_RegisterAfterWriteLeaderboardRecord_Call{Call: _e.mock.On("RegisterAfterWriteLeaderboardRecord", fn)} +} + +func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error)) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterWriteStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterWriteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterWriteStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error); ok { r0 = rf(fn) @@ -1127,10 +3741,42 @@ func (_m *MockInitializer) RegisterAfterWriteStorageObjects(fn func(context.Cont return r0 } +// MockInitializer_RegisterAfterWriteStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterWriteStorageObjects' +type MockInitializer_RegisterAfterWriteStorageObjects_Call struct { + *mock.Call +} + +// RegisterAfterWriteStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjectAcks , *api.WriteStorageObjectsRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterWriteStorageObjects(fn interface{}) *MockInitializer_RegisterAfterWriteStorageObjects_Call { + return &MockInitializer_RegisterAfterWriteStorageObjects_Call{Call: _e.mock.On("RegisterAfterWriteStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error)) *MockInitializer_RegisterAfterWriteStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterWriteStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterAfterWriteTournamentRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterAfterWriteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterAfterWriteTournamentRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error); ok { r0 = rf(fn) @@ -1141,10 +3787,42 @@ func (_m *MockInitializer) RegisterAfterWriteTournamentRecord(fn func(context.Co return r0 } +// MockInitializer_RegisterAfterWriteTournamentRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAfterWriteTournamentRecord' +type MockInitializer_RegisterAfterWriteTournamentRecord_Call struct { + *mock.Call +} + +// RegisterAfterWriteTournamentRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecord , *api.WriteTournamentRecordRequest) error +func (_e *MockInitializer_Expecter) RegisterAfterWriteTournamentRecord(fn interface{}) *MockInitializer_RegisterAfterWriteTournamentRecord_Call { + return &MockInitializer_RegisterAfterWriteTournamentRecord_Call{Call: _e.mock.On("RegisterAfterWriteTournamentRecord", fn)} +} + +func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error)) *MockInitializer_RegisterAfterWriteTournamentRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteTournamentRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error) *MockInitializer_RegisterAfterWriteTournamentRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAddFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAddFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAddFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1155,10 +3833,42 @@ func (_m *MockInitializer) RegisterBeforeAddFriends(fn func(context.Context, run return r0 } -// RegisterBeforeAddGroupUsers provides a mock function with given fields: fn -func (_m *MockInitializer) RegisterBeforeAddGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error { +// MockInitializer_RegisterBeforeAddFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAddFriends' +type MockInitializer_RegisterBeforeAddFriends_Call struct { + *mock.Call +} + +// RegisterBeforeAddFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddFriendsRequest)(*api.AddFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAddFriends(fn interface{}) *MockInitializer_RegisterBeforeAddFriends_Call { + return &MockInitializer_RegisterBeforeAddFriends_Call{Call: _e.mock.On("RegisterBeforeAddFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAddFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error))) *MockInitializer_RegisterBeforeAddFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAddFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAddFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAddFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error) *MockInitializer_RegisterBeforeAddFriends_Call { + _c.Call.Return(run) + return _c +} + +// RegisterBeforeAddGroupUsers provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterBeforeAddGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAddGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1169,10 +3879,42 @@ func (_m *MockInitializer) RegisterBeforeAddGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeAddGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAddGroupUsers' +type MockInitializer_RegisterBeforeAddGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforeAddGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddGroupUsersRequest)(*api.AddGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAddGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeAddGroupUsers_Call { + return &MockInitializer_RegisterBeforeAddGroupUsers_Call{Call: _e.mock.On("RegisterBeforeAddGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error))) *MockInitializer_RegisterBeforeAddGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAddGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeAddGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error); ok { r0 = rf(fn) @@ -1183,10 +3925,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateApple(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforeAuthenticateApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateApple' +type MockInitializer_RegisterBeforeAuthenticateApple_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateAppleRequest)(*api.AuthenticateAppleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateApple(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateApple_Call { + return &MockInitializer_RegisterBeforeAuthenticateApple_Call{Call: _e.mock.On("RegisterBeforeAuthenticateApple", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error))) *MockInitializer_RegisterBeforeAuthenticateApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error); ok { r0 = rf(fn) @@ -1197,10 +3971,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateCustom(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeAuthenticateCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateCustom' +type MockInitializer_RegisterBeforeAuthenticateCustom_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateCustomRequest)(*api.AuthenticateCustomRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateCustom(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateCustom_Call { + return &MockInitializer_RegisterBeforeAuthenticateCustom_Call{Call: _e.mock.On("RegisterBeforeAuthenticateCustom", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error))) *MockInitializer_RegisterBeforeAuthenticateCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error); ok { r0 = rf(fn) @@ -1211,10 +4017,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateDevice(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeAuthenticateDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateDevice' +type MockInitializer_RegisterBeforeAuthenticateDevice_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateDeviceRequest)(*api.AuthenticateDeviceRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateDevice(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateDevice_Call { + return &MockInitializer_RegisterBeforeAuthenticateDevice_Call{Call: _e.mock.On("RegisterBeforeAuthenticateDevice", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error))) *MockInitializer_RegisterBeforeAuthenticateDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error); ok { r0 = rf(fn) @@ -1225,10 +4063,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateEmail(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforeAuthenticateEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateEmail' +type MockInitializer_RegisterBeforeAuthenticateEmail_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateEmailRequest)(*api.AuthenticateEmailRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateEmail(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateEmail_Call { + return &MockInitializer_RegisterBeforeAuthenticateEmail_Call{Call: _e.mock.On("RegisterBeforeAuthenticateEmail", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error))) *MockInitializer_RegisterBeforeAuthenticateEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error); ok { r0 = rf(fn) @@ -1239,10 +4109,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateFacebook(fn func(context.Co return r0 } +// MockInitializer_RegisterBeforeAuthenticateFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateFacebook' +type MockInitializer_RegisterBeforeAuthenticateFacebook_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateFacebookRequest)(*api.AuthenticateFacebookRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateFacebook(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call { + return &MockInitializer_RegisterBeforeAuthenticateFacebook_Call{Call: _e.mock.On("RegisterBeforeAuthenticateFacebook", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error))) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error); ok { r0 = rf(fn) @@ -1253,10 +4155,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateFacebookInstantGame(fn func return r0 } +// MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateFacebookInstantGame' +type MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateFacebookInstantGameRequest)(*api.AuthenticateFacebookInstantGameRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call { + return &MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeAuthenticateFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error))) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error); ok { r0 = rf(fn) @@ -1267,10 +4201,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateGameCenter(fn func(context. return r0 } +// MockInitializer_RegisterBeforeAuthenticateGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateGameCenter' +type MockInitializer_RegisterBeforeAuthenticateGameCenter_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateGameCenterRequest)(*api.AuthenticateGameCenterRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateGameCenter(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call { + return &MockInitializer_RegisterBeforeAuthenticateGameCenter_Call{Call: _e.mock.On("RegisterBeforeAuthenticateGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error))) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error); ok { r0 = rf(fn) @@ -1281,10 +4247,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateGoogle(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeAuthenticateGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateGoogle' +type MockInitializer_RegisterBeforeAuthenticateGoogle_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateGoogleRequest)(*api.AuthenticateGoogleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateGoogle(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call { + return &MockInitializer_RegisterBeforeAuthenticateGoogle_Call{Call: _e.mock.On("RegisterBeforeAuthenticateGoogle", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error))) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeAuthenticateSteam provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeAuthenticateSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeAuthenticateSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error); ok { r0 = rf(fn) @@ -1295,10 +4293,42 @@ func (_m *MockInitializer) RegisterBeforeAuthenticateSteam(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforeAuthenticateSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeAuthenticateSteam' +type MockInitializer_RegisterBeforeAuthenticateSteam_Call struct { + *mock.Call +} + +// RegisterBeforeAuthenticateSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateSteamRequest)(*api.AuthenticateSteamRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateSteam(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateSteam_Call { + return &MockInitializer_RegisterBeforeAuthenticateSteam_Call{Call: _e.mock.On("RegisterBeforeAuthenticateSteam", fn)} +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error))) *MockInitializer_RegisterBeforeAuthenticateSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeBanGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeBanGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeBanGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1309,10 +4339,42 @@ func (_m *MockInitializer) RegisterBeforeBanGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeBanGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeBanGroupUsers' +type MockInitializer_RegisterBeforeBanGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforeBanGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BanGroupUsersRequest)(*api.BanGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeBanGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeBanGroupUsers_Call { + return &MockInitializer_RegisterBeforeBanGroupUsers_Call{Call: _e.mock.On("RegisterBeforeBanGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error))) *MockInitializer_RegisterBeforeBanGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeBanGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeBanGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeBlockFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeBlockFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeBlockFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1323,10 +4385,42 @@ func (_m *MockInitializer) RegisterBeforeBlockFriends(fn func(context.Context, r return r0 } +// MockInitializer_RegisterBeforeBlockFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeBlockFriends' +type MockInitializer_RegisterBeforeBlockFriends_Call struct { + *mock.Call +} + +// RegisterBeforeBlockFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BlockFriendsRequest)(*api.BlockFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeBlockFriends(fn interface{}) *MockInitializer_RegisterBeforeBlockFriends_Call { + return &MockInitializer_RegisterBeforeBlockFriends_Call{Call: _e.mock.On("RegisterBeforeBlockFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error))) *MockInitializer_RegisterBeforeBlockFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeBlockFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error) *MockInitializer_RegisterBeforeBlockFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeCreateGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeCreateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeCreateGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error); ok { r0 = rf(fn) @@ -1337,10 +4431,42 @@ func (_m *MockInitializer) RegisterBeforeCreateGroup(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeCreateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeCreateGroup' +type MockInitializer_RegisterBeforeCreateGroup_Call struct { + *mock.Call +} + +// RegisterBeforeCreateGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.CreateGroupRequest)(*api.CreateGroupRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeCreateGroup(fn interface{}) *MockInitializer_RegisterBeforeCreateGroup_Call { + return &MockInitializer_RegisterBeforeCreateGroup_Call{Call: _e.mock.On("RegisterBeforeCreateGroup", fn)} +} + +func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error))) *MockInitializer_RegisterBeforeCreateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeCreateGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error) *MockInitializer_RegisterBeforeCreateGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteAccount provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteAccount") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok { r0 = rf(fn) @@ -1351,10 +4477,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteAccount(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeDeleteAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteAccount' +type MockInitializer_RegisterBeforeDeleteAccount_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteAccount(fn interface{}) *MockInitializer_RegisterBeforeDeleteAccount_Call { + return &MockInitializer_RegisterBeforeDeleteAccount_Call{Call: _e.mock.On("RegisterBeforeDeleteAccount", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeDeleteAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeDeleteAccount_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1365,10 +4523,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteFriends(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeDeleteFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteFriends' +type MockInitializer_RegisterBeforeDeleteFriends_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteFriendsRequest)(*api.DeleteFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteFriends(fn interface{}) *MockInitializer_RegisterBeforeDeleteFriends_Call { + return &MockInitializer_RegisterBeforeDeleteFriends_Call{Call: _e.mock.On("RegisterBeforeDeleteFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error))) *MockInitializer_RegisterBeforeDeleteFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error); ok { r0 = rf(fn) @@ -1379,10 +4569,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteGroup(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeDeleteGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteGroup' +type MockInitializer_RegisterBeforeDeleteGroup_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteGroupRequest)(*api.DeleteGroupRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteGroup(fn interface{}) *MockInitializer_RegisterBeforeDeleteGroup_Call { + return &MockInitializer_RegisterBeforeDeleteGroup_Call{Call: _e.mock.On("RegisterBeforeDeleteGroup", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error))) *MockInitializer_RegisterBeforeDeleteGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error) *MockInitializer_RegisterBeforeDeleteGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteLeaderboardRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteLeaderboardRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error); ok { r0 = rf(fn) @@ -1393,10 +4615,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteLeaderboardRecord(fn func(context return r0 } +// MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteLeaderboardRecord' +type MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteLeaderboardRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteLeaderboardRecordRequest)(*api.DeleteLeaderboardRecordRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call { + return &MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call{Call: _e.mock.On("RegisterBeforeDeleteLeaderboardRecord", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error))) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteNotifications provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteNotifications") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error); ok { r0 = rf(fn) @@ -1407,10 +4661,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteNotifications(fn func(context.Con return r0 } +// MockInitializer_RegisterBeforeDeleteNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteNotifications' +type MockInitializer_RegisterBeforeDeleteNotifications_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteNotifications is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteNotificationsRequest)(*api.DeleteNotificationsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteNotifications(fn interface{}) *MockInitializer_RegisterBeforeDeleteNotifications_Call { + return &MockInitializer_RegisterBeforeDeleteNotifications_Call{Call: _e.mock.On("RegisterBeforeDeleteNotifications", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error))) *MockInitializer_RegisterBeforeDeleteNotifications_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteNotifications_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteNotifications_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error); ok { r0 = rf(fn) @@ -1421,10 +4707,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteStorageObjects(fn func(context.Co return r0 } +// MockInitializer_RegisterBeforeDeleteStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteStorageObjects' +type MockInitializer_RegisterBeforeDeleteStorageObjects_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteStorageObjectsRequest)(*api.DeleteStorageObjectsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call { + return &MockInitializer_RegisterBeforeDeleteStorageObjects_Call{Call: _e.mock.On("RegisterBeforeDeleteStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDeleteTournamentRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDeleteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDeleteTournamentRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error); ok { r0 = rf(fn) @@ -1435,10 +4753,42 @@ func (_m *MockInitializer) RegisterBeforeDeleteTournamentRecord(fn func(context. return r0 } +// MockInitializer_RegisterBeforeDeleteTournamentRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDeleteTournamentRecord' +type MockInitializer_RegisterBeforeDeleteTournamentRecord_Call struct { + *mock.Call +} + +// RegisterBeforeDeleteTournamentRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteTournamentRecordRequest)(*api.DeleteTournamentRecordRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDeleteTournamentRecord(fn interface{}) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call { + return &MockInitializer_RegisterBeforeDeleteTournamentRecord_Call{Call: _e.mock.On("RegisterBeforeDeleteTournamentRecord", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error))) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeDemoteGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeDemoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeDemoteGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1449,10 +4799,88 @@ func (_m *MockInitializer) RegisterBeforeDemoteGroupUsers(fn func(context.Contex return r0 } -// RegisterBeforeGetAccount provides a mock function with given fields: fn -func (_m *MockInitializer) RegisterBeforeGetAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error { +// MockInitializer_RegisterBeforeDemoteGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeDemoteGroupUsers' +type MockInitializer_RegisterBeforeDemoteGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforeDemoteGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DemoteGroupUsersRequest)(*api.DemoteGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeDemoteGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call { + return &MockInitializer_RegisterBeforeDemoteGroupUsers_Call{Call: _e.mock.On("RegisterBeforeDemoteGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error))) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call { + _c.Call.Return(run) + return _c +} + +// RegisterBeforeGetAccount provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterBeforeGetAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error { + ret := _m.Called(fn) + + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeGetAccount") + } + + var r0 error + if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok { + r0 = rf(fn) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockInitializer_RegisterBeforeGetAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeGetAccount' +type MockInitializer_RegisterBeforeGetAccount_Call struct { + *mock.Call +} + +// RegisterBeforeGetAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error +func (_e *MockInitializer_Expecter) RegisterBeforeGetAccount(fn interface{}) *MockInitializer_RegisterBeforeGetAccount_Call { + return &MockInitializer_RegisterBeforeGetAccount_Call{Call: _e.mock.On("RegisterBeforeGetAccount", fn)} +} + +func (_c *MockInitializer_RegisterBeforeGetAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeGetAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeGetAccount_Call { + _c.Call.Return(run) + return _c +} + +// RegisterBeforeGetMatchmakerStats provides a mock function with given fields: fn +func (_m *MockInitializer) RegisterBeforeGetMatchmakerStats(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeGetMatchmakerStats") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok { r0 = rf(fn) @@ -1463,10 +4891,42 @@ func (_m *MockInitializer) RegisterBeforeGetAccount(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeGetMatchmakerStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeGetMatchmakerStats' +type MockInitializer_RegisterBeforeGetMatchmakerStats_Call struct { + *mock.Call +} + +// RegisterBeforeGetMatchmakerStats is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error +func (_e *MockInitializer_Expecter) RegisterBeforeGetMatchmakerStats(fn interface{}) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call { + return &MockInitializer_RegisterBeforeGetMatchmakerStats_Call{Call: _e.mock.On("RegisterBeforeGetMatchmakerStats", fn)} +} + +func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeGetSubscription provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeGetSubscription(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeGetSubscription") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error); ok { r0 = rf(fn) @@ -1477,10 +4937,42 @@ func (_m *MockInitializer) RegisterBeforeGetSubscription(fn func(context.Context return r0 } +// MockInitializer_RegisterBeforeGetSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeGetSubscription' +type MockInitializer_RegisterBeforeGetSubscription_Call struct { + *mock.Call +} + +// RegisterBeforeGetSubscription is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GetSubscriptionRequest)(*api.GetSubscriptionRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeGetSubscription(fn interface{}) *MockInitializer_RegisterBeforeGetSubscription_Call { + return &MockInitializer_RegisterBeforeGetSubscription_Call{Call: _e.mock.On("RegisterBeforeGetSubscription", fn)} +} + +func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error))) *MockInitializer_RegisterBeforeGetSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetSubscription_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error) *MockInitializer_RegisterBeforeGetSubscription_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeGetUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeGetUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeGetUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1491,10 +4983,42 @@ func (_m *MockInitializer) RegisterBeforeGetUsers(fn func(context.Context, runti return r0 } +// MockInitializer_RegisterBeforeGetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeGetUsers' +type MockInitializer_RegisterBeforeGetUsers_Call struct { + *mock.Call +} + +// RegisterBeforeGetUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GetUsersRequest)(*api.GetUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeGetUsers(fn interface{}) *MockInitializer_RegisterBeforeGetUsers_Call { + return &MockInitializer_RegisterBeforeGetUsers_Call{Call: _e.mock.On("RegisterBeforeGetUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeGetUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error))) *MockInitializer_RegisterBeforeGetUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeGetUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error) *MockInitializer_RegisterBeforeGetUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeImportFacebookFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeImportFacebookFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeImportFacebookFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1505,10 +5029,42 @@ func (_m *MockInitializer) RegisterBeforeImportFacebookFriends(fn func(context.C return r0 } +// MockInitializer_RegisterBeforeImportFacebookFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeImportFacebookFriends' +type MockInitializer_RegisterBeforeImportFacebookFriends_Call struct { + *mock.Call +} + +// RegisterBeforeImportFacebookFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportFacebookFriendsRequest)(*api.ImportFacebookFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeImportFacebookFriends(fn interface{}) *MockInitializer_RegisterBeforeImportFacebookFriends_Call { + return &MockInitializer_RegisterBeforeImportFacebookFriends_Call{Call: _e.mock.On("RegisterBeforeImportFacebookFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error))) *MockInitializer_RegisterBeforeImportFacebookFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeImportFacebookFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error) *MockInitializer_RegisterBeforeImportFacebookFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeImportSteamFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeImportSteamFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeImportSteamFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1519,10 +5075,42 @@ func (_m *MockInitializer) RegisterBeforeImportSteamFriends(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeImportSteamFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeImportSteamFriends' +type MockInitializer_RegisterBeforeImportSteamFriends_Call struct { + *mock.Call +} + +// RegisterBeforeImportSteamFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportSteamFriendsRequest)(*api.ImportSteamFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeImportSteamFriends(fn interface{}) *MockInitializer_RegisterBeforeImportSteamFriends_Call { + return &MockInitializer_RegisterBeforeImportSteamFriends_Call{Call: _e.mock.On("RegisterBeforeImportSteamFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error))) *MockInitializer_RegisterBeforeImportSteamFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeImportSteamFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error) *MockInitializer_RegisterBeforeImportSteamFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeJoinGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeJoinGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeJoinGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error); ok { r0 = rf(fn) @@ -1533,10 +5121,42 @@ func (_m *MockInitializer) RegisterBeforeJoinGroup(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterBeforeJoinGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeJoinGroup' +type MockInitializer_RegisterBeforeJoinGroup_Call struct { + *mock.Call +} + +// RegisterBeforeJoinGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinGroupRequest)(*api.JoinGroupRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeJoinGroup(fn interface{}) *MockInitializer_RegisterBeforeJoinGroup_Call { + return &MockInitializer_RegisterBeforeJoinGroup_Call{Call: _e.mock.On("RegisterBeforeJoinGroup", fn)} +} + +func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error))) *MockInitializer_RegisterBeforeJoinGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeJoinGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error) *MockInitializer_RegisterBeforeJoinGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeJoinTournament provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeJoinTournament(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeJoinTournament") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error); ok { r0 = rf(fn) @@ -1547,10 +5167,42 @@ func (_m *MockInitializer) RegisterBeforeJoinTournament(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeJoinTournament_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeJoinTournament' +type MockInitializer_RegisterBeforeJoinTournament_Call struct { + *mock.Call +} + +// RegisterBeforeJoinTournament is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinTournamentRequest)(*api.JoinTournamentRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeJoinTournament(fn interface{}) *MockInitializer_RegisterBeforeJoinTournament_Call { + return &MockInitializer_RegisterBeforeJoinTournament_Call{Call: _e.mock.On("RegisterBeforeJoinTournament", fn)} +} + +func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error))) *MockInitializer_RegisterBeforeJoinTournament_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) Return(_a0 error) *MockInitializer_RegisterBeforeJoinTournament_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error) *MockInitializer_RegisterBeforeJoinTournament_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeKickGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeKickGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeKickGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1561,10 +5213,42 @@ func (_m *MockInitializer) RegisterBeforeKickGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeKickGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeKickGroupUsers' +type MockInitializer_RegisterBeforeKickGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforeKickGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.KickGroupUsersRequest)(*api.KickGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeKickGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeKickGroupUsers_Call { + return &MockInitializer_RegisterBeforeKickGroupUsers_Call{Call: _e.mock.On("RegisterBeforeKickGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error))) *MockInitializer_RegisterBeforeKickGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeKickGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeKickGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLeaveGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLeaveGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLeaveGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error); ok { r0 = rf(fn) @@ -1575,10 +5259,42 @@ func (_m *MockInitializer) RegisterBeforeLeaveGroup(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeLeaveGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLeaveGroup' +type MockInitializer_RegisterBeforeLeaveGroup_Call struct { + *mock.Call +} + +// RegisterBeforeLeaveGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaveGroupRequest)(*api.LeaveGroupRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLeaveGroup(fn interface{}) *MockInitializer_RegisterBeforeLeaveGroup_Call { + return &MockInitializer_RegisterBeforeLeaveGroup_Call{Call: _e.mock.On("RegisterBeforeLeaveGroup", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error))) *MockInitializer_RegisterBeforeLeaveGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLeaveGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error) *MockInitializer_RegisterBeforeLeaveGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error); ok { r0 = rf(fn) @@ -1589,10 +5305,42 @@ func (_m *MockInitializer) RegisterBeforeLinkApple(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterBeforeLinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkApple' +type MockInitializer_RegisterBeforeLinkApple_Call struct { + *mock.Call +} + +// RegisterBeforeLinkApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple)(*api.AccountApple , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkApple(fn interface{}) *MockInitializer_RegisterBeforeLinkApple_Call { + return &MockInitializer_RegisterBeforeLinkApple_Call{Call: _e.mock.On("RegisterBeforeLinkApple", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) *MockInitializer_RegisterBeforeLinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error) *MockInitializer_RegisterBeforeLinkApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error); ok { r0 = rf(fn) @@ -1603,10 +5351,42 @@ func (_m *MockInitializer) RegisterBeforeLinkCustom(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeLinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkCustom' +type MockInitializer_RegisterBeforeLinkCustom_Call struct { + *mock.Call +} + +// RegisterBeforeLinkCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom)(*api.AccountCustom , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkCustom(fn interface{}) *MockInitializer_RegisterBeforeLinkCustom_Call { + return &MockInitializer_RegisterBeforeLinkCustom_Call{Call: _e.mock.On("RegisterBeforeLinkCustom", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) *MockInitializer_RegisterBeforeLinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error) *MockInitializer_RegisterBeforeLinkCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error); ok { r0 = rf(fn) @@ -1617,10 +5397,42 @@ func (_m *MockInitializer) RegisterBeforeLinkDevice(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeLinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkDevice' +type MockInitializer_RegisterBeforeLinkDevice_Call struct { + *mock.Call +} + +// RegisterBeforeLinkDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice)(*api.AccountDevice , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkDevice(fn interface{}) *MockInitializer_RegisterBeforeLinkDevice_Call { + return &MockInitializer_RegisterBeforeLinkDevice_Call{Call: _e.mock.On("RegisterBeforeLinkDevice", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) *MockInitializer_RegisterBeforeLinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error) *MockInitializer_RegisterBeforeLinkDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error); ok { r0 = rf(fn) @@ -1631,10 +5443,42 @@ func (_m *MockInitializer) RegisterBeforeLinkEmail(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterBeforeLinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkEmail' +type MockInitializer_RegisterBeforeLinkEmail_Call struct { + *mock.Call +} + +// RegisterBeforeLinkEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail)(*api.AccountEmail , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkEmail(fn interface{}) *MockInitializer_RegisterBeforeLinkEmail_Call { + return &MockInitializer_RegisterBeforeLinkEmail_Call{Call: _e.mock.On("RegisterBeforeLinkEmail", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) *MockInitializer_RegisterBeforeLinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error) *MockInitializer_RegisterBeforeLinkEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error); ok { r0 = rf(fn) @@ -1645,10 +5489,42 @@ func (_m *MockInitializer) RegisterBeforeLinkFacebook(fn func(context.Context, r return r0 } +// MockInitializer_RegisterBeforeLinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkFacebook' +type MockInitializer_RegisterBeforeLinkFacebook_Call struct { + *mock.Call +} + +// RegisterBeforeLinkFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkFacebookRequest)(*api.LinkFacebookRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkFacebook(fn interface{}) *MockInitializer_RegisterBeforeLinkFacebook_Call { + return &MockInitializer_RegisterBeforeLinkFacebook_Call{Call: _e.mock.On("RegisterBeforeLinkFacebook", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error))) *MockInitializer_RegisterBeforeLinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error) *MockInitializer_RegisterBeforeLinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error); ok { r0 = rf(fn) @@ -1659,10 +5535,42 @@ func (_m *MockInitializer) RegisterBeforeLinkFacebookInstantGame(fn func(context return r0 } +// MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkFacebookInstantGame' +type MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterBeforeLinkFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame)(*api.AccountFacebookInstantGame , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call { + return &MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeLinkFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error); ok { r0 = rf(fn) @@ -1673,10 +5581,42 @@ func (_m *MockInitializer) RegisterBeforeLinkGameCenter(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeLinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkGameCenter' +type MockInitializer_RegisterBeforeLinkGameCenter_Call struct { + *mock.Call +} + +// RegisterBeforeLinkGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter)(*api.AccountGameCenter , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkGameCenter(fn interface{}) *MockInitializer_RegisterBeforeLinkGameCenter_Call { + return &MockInitializer_RegisterBeforeLinkGameCenter_Call{Call: _e.mock.On("RegisterBeforeLinkGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) *MockInitializer_RegisterBeforeLinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error) *MockInitializer_RegisterBeforeLinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error); ok { r0 = rf(fn) @@ -1687,10 +5627,42 @@ func (_m *MockInitializer) RegisterBeforeLinkGoogle(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeLinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkGoogle' +type MockInitializer_RegisterBeforeLinkGoogle_Call struct { + *mock.Call +} + +// RegisterBeforeLinkGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle)(*api.AccountGoogle , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkGoogle(fn interface{}) *MockInitializer_RegisterBeforeLinkGoogle_Call { + return &MockInitializer_RegisterBeforeLinkGoogle_Call{Call: _e.mock.On("RegisterBeforeLinkGoogle", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) *MockInitializer_RegisterBeforeLinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error) *MockInitializer_RegisterBeforeLinkGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeLinkSteam provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeLinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeLinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error); ok { r0 = rf(fn) @@ -1701,10 +5673,42 @@ func (_m *MockInitializer) RegisterBeforeLinkSteam(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterBeforeLinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeLinkSteam' +type MockInitializer_RegisterBeforeLinkSteam_Call struct { + *mock.Call +} + +// RegisterBeforeLinkSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkSteamRequest)(*api.LinkSteamRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeLinkSteam(fn interface{}) *MockInitializer_RegisterBeforeLinkSteam_Call { + return &MockInitializer_RegisterBeforeLinkSteam_Call{Call: _e.mock.On("RegisterBeforeLinkSteam", fn)} +} + +func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error))) *MockInitializer_RegisterBeforeLinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error) *MockInitializer_RegisterBeforeLinkSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListChannelMessages provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListChannelMessages(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListChannelMessages") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error); ok { r0 = rf(fn) @@ -1715,10 +5719,42 @@ func (_m *MockInitializer) RegisterBeforeListChannelMessages(fn func(context.Con return r0 } +// MockInitializer_RegisterBeforeListChannelMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListChannelMessages' +type MockInitializer_RegisterBeforeListChannelMessages_Call struct { + *mock.Call +} + +// RegisterBeforeListChannelMessages is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListChannelMessagesRequest)(*api.ListChannelMessagesRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListChannelMessages(fn interface{}) *MockInitializer_RegisterBeforeListChannelMessages_Call { + return &MockInitializer_RegisterBeforeListChannelMessages_Call{Call: _e.mock.On("RegisterBeforeListChannelMessages", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error))) *MockInitializer_RegisterBeforeListChannelMessages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListChannelMessages_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error) *MockInitializer_RegisterBeforeListChannelMessages_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1729,10 +5765,42 @@ func (_m *MockInitializer) RegisterBeforeListFriends(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeListFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListFriends' +type MockInitializer_RegisterBeforeListFriends_Call struct { + *mock.Call +} + +// RegisterBeforeListFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListFriendsRequest)(*api.ListFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListFriends(fn interface{}) *MockInitializer_RegisterBeforeListFriends_Call { + return &MockInitializer_RegisterBeforeListFriends_Call{Call: _e.mock.On("RegisterBeforeListFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error))) *MockInitializer_RegisterBeforeListFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error) *MockInitializer_RegisterBeforeListFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListFriendsOfFriends provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListFriendsOfFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListFriendsOfFriends") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error); ok { r0 = rf(fn) @@ -1743,10 +5811,42 @@ func (_m *MockInitializer) RegisterBeforeListFriendsOfFriends(fn func(context.Co return r0 } +// MockInitializer_RegisterBeforeListFriendsOfFriends_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListFriendsOfFriends' +type MockInitializer_RegisterBeforeListFriendsOfFriends_Call struct { + *mock.Call +} + +// RegisterBeforeListFriendsOfFriends is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListFriendsOfFriendsRequest)(*api.ListFriendsOfFriendsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListFriendsOfFriends(fn interface{}) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call { + return &MockInitializer_RegisterBeforeListFriendsOfFriends_Call{Call: _e.mock.On("RegisterBeforeListFriendsOfFriends", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error))) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1757,10 +5857,42 @@ func (_m *MockInitializer) RegisterBeforeListGroupUsers(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeListGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListGroupUsers' +type MockInitializer_RegisterBeforeListGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforeListGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListGroupUsersRequest)(*api.ListGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeListGroupUsers_Call { + return &MockInitializer_RegisterBeforeListGroupUsers_Call{Call: _e.mock.On("RegisterBeforeListGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error))) *MockInitializer_RegisterBeforeListGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeListGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListGroups provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListGroups") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error); ok { r0 = rf(fn) @@ -1771,10 +5903,42 @@ func (_m *MockInitializer) RegisterBeforeListGroups(fn func(context.Context, run return r0 } +// MockInitializer_RegisterBeforeListGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListGroups' +type MockInitializer_RegisterBeforeListGroups_Call struct { + *mock.Call +} + +// RegisterBeforeListGroups is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListGroupsRequest)(*api.ListGroupsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListGroups(fn interface{}) *MockInitializer_RegisterBeforeListGroups_Call { + return &MockInitializer_RegisterBeforeListGroups_Call{Call: _e.mock.On("RegisterBeforeListGroups", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error))) *MockInitializer_RegisterBeforeListGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListGroups_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error) *MockInitializer_RegisterBeforeListGroups_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListLeaderboardRecords provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListLeaderboardRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListLeaderboardRecords") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error); ok { r0 = rf(fn) @@ -1785,10 +5949,42 @@ func (_m *MockInitializer) RegisterBeforeListLeaderboardRecords(fn func(context. return r0 } +// MockInitializer_RegisterBeforeListLeaderboardRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListLeaderboardRecords' +type MockInitializer_RegisterBeforeListLeaderboardRecords_Call struct { + *mock.Call +} + +// RegisterBeforeListLeaderboardRecords is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListLeaderboardRecordsRequest)(*api.ListLeaderboardRecordsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListLeaderboardRecords(fn interface{}) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call { + return &MockInitializer_RegisterBeforeListLeaderboardRecords_Call{Call: _e.mock.On("RegisterBeforeListLeaderboardRecords", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error))) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListLeaderboardRecordsAroundOwner provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListLeaderboardRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListLeaderboardRecordsAroundOwner") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error); ok { r0 = rf(fn) @@ -1799,10 +5995,42 @@ func (_m *MockInitializer) RegisterBeforeListLeaderboardRecordsAroundOwner(fn fu return r0 } +// MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListLeaderboardRecordsAroundOwner' +type MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call struct { + *mock.Call +} + +// RegisterBeforeListLeaderboardRecordsAroundOwner is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListLeaderboardRecordsAroundOwnerRequest)(*api.ListLeaderboardRecordsAroundOwnerRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListLeaderboardRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call { + return &MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call{Call: _e.mock.On("RegisterBeforeListLeaderboardRecordsAroundOwner", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error))) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListMatches provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListMatches(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListMatches") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error); ok { r0 = rf(fn) @@ -1813,10 +6041,42 @@ func (_m *MockInitializer) RegisterBeforeListMatches(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeListMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListMatches' +type MockInitializer_RegisterBeforeListMatches_Call struct { + *mock.Call +} + +// RegisterBeforeListMatches is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListMatchesRequest)(*api.ListMatchesRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListMatches(fn interface{}) *MockInitializer_RegisterBeforeListMatches_Call { + return &MockInitializer_RegisterBeforeListMatches_Call{Call: _e.mock.On("RegisterBeforeListMatches", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListMatches_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error))) *MockInitializer_RegisterBeforeListMatches_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListMatches_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListMatches_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListMatches_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error) *MockInitializer_RegisterBeforeListMatches_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListNotifications provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListNotifications") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error); ok { r0 = rf(fn) @@ -1827,10 +6087,42 @@ func (_m *MockInitializer) RegisterBeforeListNotifications(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforeListNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListNotifications' +type MockInitializer_RegisterBeforeListNotifications_Call struct { + *mock.Call +} + +// RegisterBeforeListNotifications is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListNotificationsRequest)(*api.ListNotificationsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListNotifications(fn interface{}) *MockInitializer_RegisterBeforeListNotifications_Call { + return &MockInitializer_RegisterBeforeListNotifications_Call{Call: _e.mock.On("RegisterBeforeListNotifications", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error))) *MockInitializer_RegisterBeforeListNotifications_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListNotifications_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListNotifications_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error) *MockInitializer_RegisterBeforeListNotifications_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error); ok { r0 = rf(fn) @@ -1841,10 +6133,42 @@ func (_m *MockInitializer) RegisterBeforeListStorageObjects(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeListStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListStorageObjects' +type MockInitializer_RegisterBeforeListStorageObjects_Call struct { + *mock.Call +} + +// RegisterBeforeListStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListStorageObjectsRequest)(*api.ListStorageObjectsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeListStorageObjects_Call { + return &MockInitializer_RegisterBeforeListStorageObjects_Call{Call: _e.mock.On("RegisterBeforeListStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeListStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeListStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListSubscriptions provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListSubscriptions(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListSubscriptions") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error); ok { r0 = rf(fn) @@ -1855,10 +6179,42 @@ func (_m *MockInitializer) RegisterBeforeListSubscriptions(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforeListSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListSubscriptions' +type MockInitializer_RegisterBeforeListSubscriptions_Call struct { + *mock.Call +} + +// RegisterBeforeListSubscriptions is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListSubscriptionsRequest)(*api.ListSubscriptionsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListSubscriptions(fn interface{}) *MockInitializer_RegisterBeforeListSubscriptions_Call { + return &MockInitializer_RegisterBeforeListSubscriptions_Call{Call: _e.mock.On("RegisterBeforeListSubscriptions", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error))) *MockInitializer_RegisterBeforeListSubscriptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListSubscriptions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error) *MockInitializer_RegisterBeforeListSubscriptions_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListTournamentRecords provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListTournamentRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListTournamentRecords") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error); ok { r0 = rf(fn) @@ -1869,10 +6225,42 @@ func (_m *MockInitializer) RegisterBeforeListTournamentRecords(fn func(context.C return r0 } +// MockInitializer_RegisterBeforeListTournamentRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListTournamentRecords' +type MockInitializer_RegisterBeforeListTournamentRecords_Call struct { + *mock.Call +} + +// RegisterBeforeListTournamentRecords is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentRecordsRequest)(*api.ListTournamentRecordsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListTournamentRecords(fn interface{}) *MockInitializer_RegisterBeforeListTournamentRecords_Call { + return &MockInitializer_RegisterBeforeListTournamentRecords_Call{Call: _e.mock.On("RegisterBeforeListTournamentRecords", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error))) *MockInitializer_RegisterBeforeListTournamentRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournamentRecords_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error) *MockInitializer_RegisterBeforeListTournamentRecords_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListTournamentRecordsAroundOwner provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListTournamentRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListTournamentRecordsAroundOwner") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error); ok { r0 = rf(fn) @@ -1883,10 +6271,42 @@ func (_m *MockInitializer) RegisterBeforeListTournamentRecordsAroundOwner(fn fun return r0 } +// MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListTournamentRecordsAroundOwner' +type MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call struct { + *mock.Call +} + +// RegisterBeforeListTournamentRecordsAroundOwner is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentRecordsAroundOwnerRequest)(*api.ListTournamentRecordsAroundOwnerRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListTournamentRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call { + return &MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call{Call: _e.mock.On("RegisterBeforeListTournamentRecordsAroundOwner", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error))) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListTournaments provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListTournaments(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListTournaments") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error); ok { r0 = rf(fn) @@ -1897,10 +6317,42 @@ func (_m *MockInitializer) RegisterBeforeListTournaments(fn func(context.Context return r0 } +// MockInitializer_RegisterBeforeListTournaments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListTournaments' +type MockInitializer_RegisterBeforeListTournaments_Call struct { + *mock.Call +} + +// RegisterBeforeListTournaments is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentsRequest)(*api.ListTournamentsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListTournaments(fn interface{}) *MockInitializer_RegisterBeforeListTournaments_Call { + return &MockInitializer_RegisterBeforeListTournaments_Call{Call: _e.mock.On("RegisterBeforeListTournaments", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListTournaments_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error))) *MockInitializer_RegisterBeforeListTournaments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournaments_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournaments_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListTournaments_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error) *MockInitializer_RegisterBeforeListTournaments_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeListUserGroups provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeListUserGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeListUserGroups") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error); ok { r0 = rf(fn) @@ -1911,10 +6363,42 @@ func (_m *MockInitializer) RegisterBeforeListUserGroups(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeListUserGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeListUserGroups' +type MockInitializer_RegisterBeforeListUserGroups_Call struct { + *mock.Call +} + +// RegisterBeforeListUserGroups is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListUserGroupsRequest)(*api.ListUserGroupsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeListUserGroups(fn interface{}) *MockInitializer_RegisterBeforeListUserGroups_Call { + return &MockInitializer_RegisterBeforeListUserGroups_Call{Call: _e.mock.On("RegisterBeforeListUserGroups", fn)} +} + +func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error))) *MockInitializer_RegisterBeforeListUserGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListUserGroups_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error) *MockInitializer_RegisterBeforeListUserGroups_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforePromoteGroupUsers provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforePromoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforePromoteGroupUsers") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error); ok { r0 = rf(fn) @@ -1925,10 +6409,42 @@ func (_m *MockInitializer) RegisterBeforePromoteGroupUsers(fn func(context.Conte return r0 } +// MockInitializer_RegisterBeforePromoteGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforePromoteGroupUsers' +type MockInitializer_RegisterBeforePromoteGroupUsers_Call struct { + *mock.Call +} + +// RegisterBeforePromoteGroupUsers is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.PromoteGroupUsersRequest)(*api.PromoteGroupUsersRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforePromoteGroupUsers(fn interface{}) *MockInitializer_RegisterBeforePromoteGroupUsers_Call { + return &MockInitializer_RegisterBeforePromoteGroupUsers_Call{Call: _e.mock.On("RegisterBeforePromoteGroupUsers", fn)} +} + +func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error))) *MockInitializer_RegisterBeforePromoteGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforePromoteGroupUsers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforePromoteGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeReadStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeReadStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeReadStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error); ok { r0 = rf(fn) @@ -1939,10 +6455,42 @@ func (_m *MockInitializer) RegisterBeforeReadStorageObjects(fn func(context.Cont return r0 } +// MockInitializer_RegisterBeforeReadStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeReadStorageObjects' +type MockInitializer_RegisterBeforeReadStorageObjects_Call struct { + *mock.Call +} + +// RegisterBeforeReadStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ReadStorageObjectsRequest)(*api.ReadStorageObjectsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeReadStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeReadStorageObjects_Call { + return &MockInitializer_RegisterBeforeReadStorageObjects_Call{Call: _e.mock.On("RegisterBeforeReadStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeReadStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeReadStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeReadStorageObjects_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeRt provides a mock function with given fields: id, fn func (_m *MockInitializer) RegisterBeforeRt(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error { ret := _m.Called(id, fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeRt") + } + var r0 error if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error); ok { r0 = rf(id, fn) @@ -1950,13 +6498,46 @@ func (_m *MockInitializer) RegisterBeforeRt(id string, fn func(context.Context, r0 = ret.Error(0) } - return r0 + return r0 +} + +// MockInitializer_RegisterBeforeRt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeRt' +type MockInitializer_RegisterBeforeRt_Call struct { + *mock.Call +} + +// RegisterBeforeRt is a helper method to define mock.On call +// - id string +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *rtapi.Envelope)(*rtapi.Envelope , error) +func (_e *MockInitializer_Expecter) RegisterBeforeRt(id interface{}, fn interface{}) *MockInitializer_RegisterBeforeRt_Call { + return &MockInitializer_RegisterBeforeRt_Call{Call: _e.mock.On("RegisterBeforeRt", id, fn)} +} + +func (_c *MockInitializer_RegisterBeforeRt_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error))) *MockInitializer_RegisterBeforeRt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeRt_Call) Return(_a0 error) *MockInitializer_RegisterBeforeRt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeRt_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error) *MockInitializer_RegisterBeforeRt_Call { + _c.Call.Return(run) + return _c } // RegisterBeforeSessionLogout provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeSessionLogout(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeSessionLogout") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error); ok { r0 = rf(fn) @@ -1967,10 +6548,42 @@ func (_m *MockInitializer) RegisterBeforeSessionLogout(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeSessionLogout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeSessionLogout' +type MockInitializer_RegisterBeforeSessionLogout_Call struct { + *mock.Call +} + +// RegisterBeforeSessionLogout is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionLogoutRequest)(*api.SessionLogoutRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeSessionLogout(fn interface{}) *MockInitializer_RegisterBeforeSessionLogout_Call { + return &MockInitializer_RegisterBeforeSessionLogout_Call{Call: _e.mock.On("RegisterBeforeSessionLogout", fn)} +} + +func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error))) *MockInitializer_RegisterBeforeSessionLogout_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) Return(_a0 error) *MockInitializer_RegisterBeforeSessionLogout_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error) *MockInitializer_RegisterBeforeSessionLogout_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeSessionRefresh provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeSessionRefresh(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeSessionRefresh") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error); ok { r0 = rf(fn) @@ -1981,10 +6594,42 @@ func (_m *MockInitializer) RegisterBeforeSessionRefresh(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeSessionRefresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeSessionRefresh' +type MockInitializer_RegisterBeforeSessionRefresh_Call struct { + *mock.Call +} + +// RegisterBeforeSessionRefresh is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionRefreshRequest)(*api.SessionRefreshRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeSessionRefresh(fn interface{}) *MockInitializer_RegisterBeforeSessionRefresh_Call { + return &MockInitializer_RegisterBeforeSessionRefresh_Call{Call: _e.mock.On("RegisterBeforeSessionRefresh", fn)} +} + +func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error))) *MockInitializer_RegisterBeforeSessionRefresh_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) Return(_a0 error) *MockInitializer_RegisterBeforeSessionRefresh_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error) *MockInitializer_RegisterBeforeSessionRefresh_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error); ok { r0 = rf(fn) @@ -1995,10 +6640,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkApple(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeUnlinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkApple' +type MockInitializer_RegisterBeforeUnlinkApple_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple)(*api.AccountApple , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkApple(fn interface{}) *MockInitializer_RegisterBeforeUnlinkApple_Call { + return &MockInitializer_RegisterBeforeUnlinkApple_Call{Call: _e.mock.On("RegisterBeforeUnlinkApple", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) *MockInitializer_RegisterBeforeUnlinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error) *MockInitializer_RegisterBeforeUnlinkApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkCustom provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error); ok { r0 = rf(fn) @@ -2009,10 +6686,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkCustom(fn func(context.Context, r return r0 } +// MockInitializer_RegisterBeforeUnlinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkCustom' +type MockInitializer_RegisterBeforeUnlinkCustom_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkCustom is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom)(*api.AccountCustom , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkCustom(fn interface{}) *MockInitializer_RegisterBeforeUnlinkCustom_Call { + return &MockInitializer_RegisterBeforeUnlinkCustom_Call{Call: _e.mock.On("RegisterBeforeUnlinkCustom", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) *MockInitializer_RegisterBeforeUnlinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error) *MockInitializer_RegisterBeforeUnlinkCustom_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkDevice provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error); ok { r0 = rf(fn) @@ -2023,10 +6732,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkDevice(fn func(context.Context, r return r0 } +// MockInitializer_RegisterBeforeUnlinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkDevice' +type MockInitializer_RegisterBeforeUnlinkDevice_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkDevice is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice)(*api.AccountDevice , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkDevice(fn interface{}) *MockInitializer_RegisterBeforeUnlinkDevice_Call { + return &MockInitializer_RegisterBeforeUnlinkDevice_Call{Call: _e.mock.On("RegisterBeforeUnlinkDevice", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) *MockInitializer_RegisterBeforeUnlinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error) *MockInitializer_RegisterBeforeUnlinkDevice_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkEmail provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error); ok { r0 = rf(fn) @@ -2037,10 +6778,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkEmail(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeUnlinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkEmail' +type MockInitializer_RegisterBeforeUnlinkEmail_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkEmail is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail)(*api.AccountEmail , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkEmail(fn interface{}) *MockInitializer_RegisterBeforeUnlinkEmail_Call { + return &MockInitializer_RegisterBeforeUnlinkEmail_Call{Call: _e.mock.On("RegisterBeforeUnlinkEmail", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) *MockInitializer_RegisterBeforeUnlinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error) *MockInitializer_RegisterBeforeUnlinkEmail_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkFacebook provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error); ok { r0 = rf(fn) @@ -2051,10 +6824,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkFacebook(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeUnlinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkFacebook' +type MockInitializer_RegisterBeforeUnlinkFacebook_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkFacebook is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebook)(*api.AccountFacebook , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkFacebook(fn interface{}) *MockInitializer_RegisterBeforeUnlinkFacebook_Call { + return &MockInitializer_RegisterBeforeUnlinkFacebook_Call{Call: _e.mock.On("RegisterBeforeUnlinkFacebook", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error))) *MockInitializer_RegisterBeforeUnlinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error) *MockInitializer_RegisterBeforeUnlinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkFacebookInstantGame provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error); ok { r0 = rf(fn) @@ -2065,10 +6870,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkFacebookInstantGame(fn func(conte return r0 } +// MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkFacebookInstantGame' +type MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkFacebookInstantGame is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame)(*api.AccountFacebookInstantGame , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call { + return &MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeUnlinkFacebookInstantGame", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkGameCenter provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error); ok { r0 = rf(fn) @@ -2079,10 +6916,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkGameCenter(fn func(context.Contex return r0 } +// MockInitializer_RegisterBeforeUnlinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkGameCenter' +type MockInitializer_RegisterBeforeUnlinkGameCenter_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkGameCenter is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter)(*api.AccountGameCenter , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkGameCenter(fn interface{}) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call { + return &MockInitializer_RegisterBeforeUnlinkGameCenter_Call{Call: _e.mock.On("RegisterBeforeUnlinkGameCenter", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error); ok { r0 = rf(fn) @@ -2093,10 +6962,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkGoogle(fn func(context.Context, r return r0 } +// MockInitializer_RegisterBeforeUnlinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkGoogle' +type MockInitializer_RegisterBeforeUnlinkGoogle_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle)(*api.AccountGoogle , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkGoogle(fn interface{}) *MockInitializer_RegisterBeforeUnlinkGoogle_Call { + return &MockInitializer_RegisterBeforeUnlinkGoogle_Call{Call: _e.mock.On("RegisterBeforeUnlinkGoogle", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) *MockInitializer_RegisterBeforeUnlinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error) *MockInitializer_RegisterBeforeUnlinkGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUnlinkSteam provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUnlinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUnlinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error); ok { r0 = rf(fn) @@ -2107,10 +7008,42 @@ func (_m *MockInitializer) RegisterBeforeUnlinkSteam(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeUnlinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUnlinkSteam' +type MockInitializer_RegisterBeforeUnlinkSteam_Call struct { + *mock.Call +} + +// RegisterBeforeUnlinkSteam is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountSteam)(*api.AccountSteam , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkSteam(fn interface{}) *MockInitializer_RegisterBeforeUnlinkSteam_Call { + return &MockInitializer_RegisterBeforeUnlinkSteam_Call{Call: _e.mock.On("RegisterBeforeUnlinkSteam", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error))) *MockInitializer_RegisterBeforeUnlinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error) *MockInitializer_RegisterBeforeUnlinkSteam_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUpdateAccount provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUpdateAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUpdateAccount") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error); ok { r0 = rf(fn) @@ -2121,10 +7054,42 @@ func (_m *MockInitializer) RegisterBeforeUpdateAccount(fn func(context.Context, return r0 } +// MockInitializer_RegisterBeforeUpdateAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUpdateAccount' +type MockInitializer_RegisterBeforeUpdateAccount_Call struct { + *mock.Call +} + +// RegisterBeforeUpdateAccount is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateAccountRequest)(*api.UpdateAccountRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUpdateAccount(fn interface{}) *MockInitializer_RegisterBeforeUpdateAccount_Call { + return &MockInitializer_RegisterBeforeUpdateAccount_Call{Call: _e.mock.On("RegisterBeforeUpdateAccount", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error))) *MockInitializer_RegisterBeforeUpdateAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUpdateAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error) *MockInitializer_RegisterBeforeUpdateAccount_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeUpdateGroup provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeUpdateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeUpdateGroup") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error); ok { r0 = rf(fn) @@ -2135,10 +7100,42 @@ func (_m *MockInitializer) RegisterBeforeUpdateGroup(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterBeforeUpdateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeUpdateGroup' +type MockInitializer_RegisterBeforeUpdateGroup_Call struct { + *mock.Call +} + +// RegisterBeforeUpdateGroup is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateGroupRequest)(*api.UpdateGroupRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeUpdateGroup(fn interface{}) *MockInitializer_RegisterBeforeUpdateGroup_Call { + return &MockInitializer_RegisterBeforeUpdateGroup_Call{Call: _e.mock.On("RegisterBeforeUpdateGroup", fn)} +} + +func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error))) *MockInitializer_RegisterBeforeUpdateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUpdateGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error) *MockInitializer_RegisterBeforeUpdateGroup_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidatePurchaseApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidatePurchaseApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidatePurchaseApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error); ok { r0 = rf(fn) @@ -2149,10 +7146,42 @@ func (_m *MockInitializer) RegisterBeforeValidatePurchaseApple(fn func(context.C return r0 } +// MockInitializer_RegisterBeforeValidatePurchaseApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidatePurchaseApple' +type MockInitializer_RegisterBeforeValidatePurchaseApple_Call struct { + *mock.Call +} + +// RegisterBeforeValidatePurchaseApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseAppleRequest)(*api.ValidatePurchaseAppleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseApple(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call { + return &MockInitializer_RegisterBeforeValidatePurchaseApple_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseApple", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidatePurchaseFacebookInstant provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidatePurchaseFacebookInstant(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidatePurchaseFacebookInstant") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error); ok { r0 = rf(fn) @@ -2163,10 +7192,42 @@ func (_m *MockInitializer) RegisterBeforeValidatePurchaseFacebookInstant(fn func return r0 } +// MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidatePurchaseFacebookInstant' +type MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call struct { + *mock.Call +} + +// RegisterBeforeValidatePurchaseFacebookInstant is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseFacebookInstantRequest)(*api.ValidatePurchaseFacebookInstantRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseFacebookInstant(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call { + return &MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseFacebookInstant", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidatePurchaseGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidatePurchaseGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidatePurchaseGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error); ok { r0 = rf(fn) @@ -2177,10 +7238,42 @@ func (_m *MockInitializer) RegisterBeforeValidatePurchaseGoogle(fn func(context. return r0 } +// MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidatePurchaseGoogle' +type MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call struct { + *mock.Call +} + +// RegisterBeforeValidatePurchaseGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseGoogleRequest)(*api.ValidatePurchaseGoogleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseGoogle(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call { + return &MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseGoogle", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidatePurchaseHuawei provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidatePurchaseHuawei(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidatePurchaseHuawei") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error); ok { r0 = rf(fn) @@ -2191,10 +7284,42 @@ func (_m *MockInitializer) RegisterBeforeValidatePurchaseHuawei(fn func(context. return r0 } +// MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidatePurchaseHuawei' +type MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call struct { + *mock.Call +} + +// RegisterBeforeValidatePurchaseHuawei is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseHuaweiRequest)(*api.ValidatePurchaseHuaweiRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseHuawei(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call { + return &MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseHuawei", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidateSubscriptionApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidateSubscriptionApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidateSubscriptionApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error); ok { r0 = rf(fn) @@ -2205,10 +7330,42 @@ func (_m *MockInitializer) RegisterBeforeValidateSubscriptionApple(fn func(conte return r0 } +// MockInitializer_RegisterBeforeValidateSubscriptionApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidateSubscriptionApple' +type MockInitializer_RegisterBeforeValidateSubscriptionApple_Call struct { + *mock.Call +} + +// RegisterBeforeValidateSubscriptionApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionAppleRequest)(*api.ValidateSubscriptionAppleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidateSubscriptionApple(fn interface{}) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call { + return &MockInitializer_RegisterBeforeValidateSubscriptionApple_Call{Call: _e.mock.On("RegisterBeforeValidateSubscriptionApple", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error))) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeValidateSubscriptionGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeValidateSubscriptionGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeValidateSubscriptionGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error); ok { r0 = rf(fn) @@ -2219,10 +7376,42 @@ func (_m *MockInitializer) RegisterBeforeValidateSubscriptionGoogle(fn func(cont return r0 } +// MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeValidateSubscriptionGoogle' +type MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call struct { + *mock.Call +} + +// RegisterBeforeValidateSubscriptionGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionGoogleRequest)(*api.ValidateSubscriptionGoogleRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeValidateSubscriptionGoogle(fn interface{}) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call { + return &MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call{Call: _e.mock.On("RegisterBeforeValidateSubscriptionGoogle", fn)} +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error))) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeWriteLeaderboardRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeWriteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeWriteLeaderboardRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error); ok { r0 = rf(fn) @@ -2233,10 +7422,42 @@ func (_m *MockInitializer) RegisterBeforeWriteLeaderboardRecord(fn func(context. return r0 } +// MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeWriteLeaderboardRecord' +type MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call struct { + *mock.Call +} + +// RegisterBeforeWriteLeaderboardRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteLeaderboardRecordRequest)(*api.WriteLeaderboardRecordRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeWriteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call { + return &MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call{Call: _e.mock.On("RegisterBeforeWriteLeaderboardRecord", fn)} +} + +func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error))) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterBeforeWriteStorageObjects provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeWriteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeWriteStorageObjects") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error); ok { r0 = rf(fn) @@ -2244,13 +7465,45 @@ func (_m *MockInitializer) RegisterBeforeWriteStorageObjects(fn func(context.Con r0 = ret.Error(0) } - return r0 + return r0 +} + +// MockInitializer_RegisterBeforeWriteStorageObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeWriteStorageObjects' +type MockInitializer_RegisterBeforeWriteStorageObjects_Call struct { + *mock.Call +} + +// RegisterBeforeWriteStorageObjects is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteStorageObjectsRequest)(*api.WriteStorageObjectsRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeWriteStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeWriteStorageObjects_Call { + return &MockInitializer_RegisterBeforeWriteStorageObjects_Call{Call: _e.mock.On("RegisterBeforeWriteStorageObjects", fn)} +} + +func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeWriteStorageObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteStorageObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeWriteStorageObjects_Call { + _c.Call.Return(run) + return _c } // RegisterBeforeWriteTournamentRecord provides a mock function with given fields: fn func (_m *MockInitializer) RegisterBeforeWriteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterBeforeWriteTournamentRecord") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error); ok { r0 = rf(fn) @@ -2261,10 +7514,42 @@ func (_m *MockInitializer) RegisterBeforeWriteTournamentRecord(fn func(context.C return r0 } +// MockInitializer_RegisterBeforeWriteTournamentRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBeforeWriteTournamentRecord' +type MockInitializer_RegisterBeforeWriteTournamentRecord_Call struct { + *mock.Call +} + +// RegisterBeforeWriteTournamentRecord is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteTournamentRecordRequest)(*api.WriteTournamentRecordRequest , error) +func (_e *MockInitializer_Expecter) RegisterBeforeWriteTournamentRecord(fn interface{}) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call { + return &MockInitializer_RegisterBeforeWriteTournamentRecord_Call{Call: _e.mock.On("RegisterBeforeWriteTournamentRecord", fn)} +} + +func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error))) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call { + _c.Call.Return(run) + return _c +} + // RegisterEvent provides a mock function with given fields: fn func (_m *MockInitializer) RegisterEvent(fn func(context.Context, runtime.Logger, *api.Event)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterEvent") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok { r0 = rf(fn) @@ -2275,10 +7560,42 @@ func (_m *MockInitializer) RegisterEvent(fn func(context.Context, runtime.Logger return r0 } +// MockInitializer_RegisterEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterEvent' +type MockInitializer_RegisterEvent_Call struct { + *mock.Call +} + +// RegisterEvent is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *api.Event) +func (_e *MockInitializer_Expecter) RegisterEvent(fn interface{}) *MockInitializer_RegisterEvent_Call { + return &MockInitializer_RegisterEvent_Call{Call: _e.mock.On("RegisterEvent", fn)} +} + +func (_c *MockInitializer_RegisterEvent_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEvent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *api.Event))) + }) + return _c +} + +func (_c *MockInitializer_RegisterEvent_Call) Return(_a0 error) *MockInitializer_RegisterEvent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterEvent_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEvent_Call { + _c.Call.Return(run) + return _c +} + // RegisterEventSessionEnd provides a mock function with given fields: fn func (_m *MockInitializer) RegisterEventSessionEnd(fn func(context.Context, runtime.Logger, *api.Event)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterEventSessionEnd") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok { r0 = rf(fn) @@ -2289,10 +7606,42 @@ func (_m *MockInitializer) RegisterEventSessionEnd(fn func(context.Context, runt return r0 } +// MockInitializer_RegisterEventSessionEnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterEventSessionEnd' +type MockInitializer_RegisterEventSessionEnd_Call struct { + *mock.Call +} + +// RegisterEventSessionEnd is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *api.Event) +func (_e *MockInitializer_Expecter) RegisterEventSessionEnd(fn interface{}) *MockInitializer_RegisterEventSessionEnd_Call { + return &MockInitializer_RegisterEventSessionEnd_Call{Call: _e.mock.On("RegisterEventSessionEnd", fn)} +} + +func (_c *MockInitializer_RegisterEventSessionEnd_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEventSessionEnd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *api.Event))) + }) + return _c +} + +func (_c *MockInitializer_RegisterEventSessionEnd_Call) Return(_a0 error) *MockInitializer_RegisterEventSessionEnd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterEventSessionEnd_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEventSessionEnd_Call { + _c.Call.Return(run) + return _c +} + // RegisterEventSessionStart provides a mock function with given fields: fn func (_m *MockInitializer) RegisterEventSessionStart(fn func(context.Context, runtime.Logger, *api.Event)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterEventSessionStart") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok { r0 = rf(fn) @@ -2303,10 +7652,42 @@ func (_m *MockInitializer) RegisterEventSessionStart(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterEventSessionStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterEventSessionStart' +type MockInitializer_RegisterEventSessionStart_Call struct { + *mock.Call +} + +// RegisterEventSessionStart is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *api.Event) +func (_e *MockInitializer_Expecter) RegisterEventSessionStart(fn interface{}) *MockInitializer_RegisterEventSessionStart_Call { + return &MockInitializer_RegisterEventSessionStart_Call{Call: _e.mock.On("RegisterEventSessionStart", fn)} +} + +func (_c *MockInitializer_RegisterEventSessionStart_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEventSessionStart_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *api.Event))) + }) + return _c +} + +func (_c *MockInitializer_RegisterEventSessionStart_Call) Return(_a0 error) *MockInitializer_RegisterEventSessionStart_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterEventSessionStart_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEventSessionStart_Call { + _c.Call.Return(run) + return _c +} + // RegisterFleetManager provides a mock function with given fields: fleetManagerInit func (_m *MockInitializer) RegisterFleetManager(fleetManagerInit runtime.FleetManagerInitializer) error { ret := _m.Called(fleetManagerInit) + if len(ret) == 0 { + panic("no return value specified for RegisterFleetManager") + } + var r0 error if rf, ok := ret.Get(0).(func(runtime.FleetManagerInitializer) error); ok { r0 = rf(fleetManagerInit) @@ -2317,10 +7698,104 @@ func (_m *MockInitializer) RegisterFleetManager(fleetManagerInit runtime.FleetMa return r0 } +// MockInitializer_RegisterFleetManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterFleetManager' +type MockInitializer_RegisterFleetManager_Call struct { + *mock.Call +} + +// RegisterFleetManager is a helper method to define mock.On call +// - fleetManagerInit runtime.FleetManagerInitializer +func (_e *MockInitializer_Expecter) RegisterFleetManager(fleetManagerInit interface{}) *MockInitializer_RegisterFleetManager_Call { + return &MockInitializer_RegisterFleetManager_Call{Call: _e.mock.On("RegisterFleetManager", fleetManagerInit)} +} + +func (_c *MockInitializer_RegisterFleetManager_Call) Run(run func(fleetManagerInit runtime.FleetManagerInitializer)) *MockInitializer_RegisterFleetManager_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.FleetManagerInitializer)) + }) + return _c +} + +func (_c *MockInitializer_RegisterFleetManager_Call) Return(_a0 error) *MockInitializer_RegisterFleetManager_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterFleetManager_Call) RunAndReturn(run func(runtime.FleetManagerInitializer) error) *MockInitializer_RegisterFleetManager_Call { + _c.Call.Return(run) + return _c +} + +// RegisterHttp provides a mock function with given fields: pathPattern, handler, methods +func (_m *MockInitializer) RegisterHttp(pathPattern string, handler func(http.ResponseWriter, *http.Request), methods ...string) error { + _va := make([]interface{}, len(methods)) + for _i := range methods { + _va[_i] = methods[_i] + } + var _ca []interface{} + _ca = append(_ca, pathPattern, handler) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RegisterHttp") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, func(http.ResponseWriter, *http.Request), ...string) error); ok { + r0 = rf(pathPattern, handler, methods...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockInitializer_RegisterHttp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHttp' +type MockInitializer_RegisterHttp_Call struct { + *mock.Call +} + +// RegisterHttp is a helper method to define mock.On call +// - pathPattern string +// - handler func(http.ResponseWriter , *http.Request) +// - methods ...string +func (_e *MockInitializer_Expecter) RegisterHttp(pathPattern interface{}, handler interface{}, methods ...interface{}) *MockInitializer_RegisterHttp_Call { + return &MockInitializer_RegisterHttp_Call{Call: _e.mock.On("RegisterHttp", + append([]interface{}{pathPattern, handler}, methods...)...)} +} + +func (_c *MockInitializer_RegisterHttp_Call) Run(run func(pathPattern string, handler func(http.ResponseWriter, *http.Request), methods ...string)) *MockInitializer_RegisterHttp_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(string), args[1].(func(http.ResponseWriter, *http.Request)), variadicArgs...) + }) + return _c +} + +func (_c *MockInitializer_RegisterHttp_Call) Return(_a0 error) *MockInitializer_RegisterHttp_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterHttp_Call) RunAndReturn(run func(string, func(http.ResponseWriter, *http.Request), ...string) error) *MockInitializer_RegisterHttp_Call { + _c.Call.Return(run) + return _c +} + // RegisterLeaderboardReset provides a mock function with given fields: fn func (_m *MockInitializer) RegisterLeaderboardReset(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterLeaderboardReset") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error); ok { r0 = rf(fn) @@ -2331,10 +7806,42 @@ func (_m *MockInitializer) RegisterLeaderboardReset(fn func(context.Context, run return r0 } +// MockInitializer_RegisterLeaderboardReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterLeaderboardReset' +type MockInitializer_RegisterLeaderboardReset_Call struct { + *mock.Call +} + +// RegisterLeaderboardReset is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Leaderboard , int64) error +func (_e *MockInitializer_Expecter) RegisterLeaderboardReset(fn interface{}) *MockInitializer_RegisterLeaderboardReset_Call { + return &MockInitializer_RegisterLeaderboardReset_Call{Call: _e.mock.On("RegisterLeaderboardReset", fn)} +} + +func (_c *MockInitializer_RegisterLeaderboardReset_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error)) *MockInitializer_RegisterLeaderboardReset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterLeaderboardReset_Call) Return(_a0 error) *MockInitializer_RegisterLeaderboardReset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterLeaderboardReset_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error) *MockInitializer_RegisterLeaderboardReset_Call { + _c.Call.Return(run) + return _c +} + // RegisterMatch provides a mock function with given fields: name, fn func (_m *MockInitializer) RegisterMatch(name string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error { ret := _m.Called(name, fn) + if len(ret) == 0 { + panic("no return value specified for RegisterMatch") + } + var r0 error if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error); ok { r0 = rf(name, fn) @@ -2345,10 +7852,43 @@ func (_m *MockInitializer) RegisterMatch(name string, fn func(context.Context, r return r0 } +// MockInitializer_RegisterMatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterMatch' +type MockInitializer_RegisterMatch_Call struct { + *mock.Call +} + +// RegisterMatch is a helper method to define mock.On call +// - name string +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule)(runtime.Match , error) +func (_e *MockInitializer_Expecter) RegisterMatch(name interface{}, fn interface{}) *MockInitializer_RegisterMatch_Call { + return &MockInitializer_RegisterMatch_Call{Call: _e.mock.On("RegisterMatch", name, fn)} +} + +func (_c *MockInitializer_RegisterMatch_Call) Run(run func(name string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error))) *MockInitializer_RegisterMatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterMatch_Call) Return(_a0 error) *MockInitializer_RegisterMatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterMatch_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error) *MockInitializer_RegisterMatch_Call { + _c.Call.Return(run) + return _c +} + // RegisterMatchmakerMatched provides a mock function with given fields: fn func (_m *MockInitializer) RegisterMatchmakerMatched(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterMatchmakerMatched") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error); ok { r0 = rf(fn) @@ -2359,10 +7899,42 @@ func (_m *MockInitializer) RegisterMatchmakerMatched(fn func(context.Context, ru return r0 } +// MockInitializer_RegisterMatchmakerMatched_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterMatchmakerMatched' +type MockInitializer_RegisterMatchmakerMatched_Call struct { + *mock.Call +} + +// RegisterMatchmakerMatched is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , []runtime.MatchmakerEntry)(string , error) +func (_e *MockInitializer_Expecter) RegisterMatchmakerMatched(fn interface{}) *MockInitializer_RegisterMatchmakerMatched_Call { + return &MockInitializer_RegisterMatchmakerMatched_Call{Call: _e.mock.On("RegisterMatchmakerMatched", fn)} +} + +func (_c *MockInitializer_RegisterMatchmakerMatched_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error))) *MockInitializer_RegisterMatchmakerMatched_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterMatchmakerMatched_Call) Return(_a0 error) *MockInitializer_RegisterMatchmakerMatched_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterMatchmakerMatched_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error) *MockInitializer_RegisterMatchmakerMatched_Call { + _c.Call.Return(run) + return _c +} + // RegisterMatchmakerOverride provides a mock function with given fields: fn func (_m *MockInitializer) RegisterMatchmakerOverride(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterMatchmakerOverride") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error); ok { r0 = rf(fn) @@ -2373,10 +7945,42 @@ func (_m *MockInitializer) RegisterMatchmakerOverride(fn func(context.Context, r return r0 } +// MockInitializer_RegisterMatchmakerOverride_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterMatchmakerOverride' +type MockInitializer_RegisterMatchmakerOverride_Call struct { + *mock.Call +} + +// RegisterMatchmakerOverride is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry +func (_e *MockInitializer_Expecter) RegisterMatchmakerOverride(fn interface{}) *MockInitializer_RegisterMatchmakerOverride_Call { + return &MockInitializer_RegisterMatchmakerOverride_Call{Call: _e.mock.On("RegisterMatchmakerOverride", fn)} +} + +func (_c *MockInitializer_RegisterMatchmakerOverride_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry)) *MockInitializer_RegisterMatchmakerOverride_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry)) + }) + return _c +} + +func (_c *MockInitializer_RegisterMatchmakerOverride_Call) Return(_a0 error) *MockInitializer_RegisterMatchmakerOverride_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterMatchmakerOverride_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error) *MockInitializer_RegisterMatchmakerOverride_Call { + _c.Call.Return(run) + return _c +} + // RegisterPurchaseNotificationApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterPurchaseNotificationApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterPurchaseNotificationApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error); ok { r0 = rf(fn) @@ -2387,10 +7991,42 @@ func (_m *MockInitializer) RegisterPurchaseNotificationApple(fn func(context.Con return r0 } +// MockInitializer_RegisterPurchaseNotificationApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterPurchaseNotificationApple' +type MockInitializer_RegisterPurchaseNotificationApple_Call struct { + *mock.Call +} + +// RegisterPurchaseNotificationApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedPurchase , string) error +func (_e *MockInitializer_Expecter) RegisterPurchaseNotificationApple(fn interface{}) *MockInitializer_RegisterPurchaseNotificationApple_Call { + return &MockInitializer_RegisterPurchaseNotificationApple_Call{Call: _e.mock.On("RegisterPurchaseNotificationApple", fn)} +} + +func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) *MockInitializer_RegisterPurchaseNotificationApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) Return(_a0 error) *MockInitializer_RegisterPurchaseNotificationApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error) *MockInitializer_RegisterPurchaseNotificationApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterPurchaseNotificationGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterPurchaseNotificationGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterPurchaseNotificationGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error); ok { r0 = rf(fn) @@ -2401,10 +8037,42 @@ func (_m *MockInitializer) RegisterPurchaseNotificationGoogle(fn func(context.Co return r0 } +// MockInitializer_RegisterPurchaseNotificationGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterPurchaseNotificationGoogle' +type MockInitializer_RegisterPurchaseNotificationGoogle_Call struct { + *mock.Call +} + +// RegisterPurchaseNotificationGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedPurchase , string) error +func (_e *MockInitializer_Expecter) RegisterPurchaseNotificationGoogle(fn interface{}) *MockInitializer_RegisterPurchaseNotificationGoogle_Call { + return &MockInitializer_RegisterPurchaseNotificationGoogle_Call{Call: _e.mock.On("RegisterPurchaseNotificationGoogle", fn)} +} + +func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) *MockInitializer_RegisterPurchaseNotificationGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) Return(_a0 error) *MockInitializer_RegisterPurchaseNotificationGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error) *MockInitializer_RegisterPurchaseNotificationGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterRpc provides a mock function with given fields: id, fn func (_m *MockInitializer) RegisterRpc(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error { ret := _m.Called(id, fn) + if len(ret) == 0 { + panic("no return value specified for RegisterRpc") + } + var r0 error if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error); ok { r0 = rf(id, fn) @@ -2415,10 +8083,43 @@ func (_m *MockInitializer) RegisterRpc(id string, fn func(context.Context, runti return r0 } +// MockInitializer_RegisterRpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterRpc' +type MockInitializer_RegisterRpc_Call struct { + *mock.Call +} + +// RegisterRpc is a helper method to define mock.On call +// - id string +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , string)(string , error) +func (_e *MockInitializer_Expecter) RegisterRpc(id interface{}, fn interface{}) *MockInitializer_RegisterRpc_Call { + return &MockInitializer_RegisterRpc_Call{Call: _e.mock.On("RegisterRpc", id, fn)} +} + +func (_c *MockInitializer_RegisterRpc_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error))) *MockInitializer_RegisterRpc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error))) + }) + return _c +} + +func (_c *MockInitializer_RegisterRpc_Call) Return(_a0 error) *MockInitializer_RegisterRpc_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterRpc_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error) *MockInitializer_RegisterRpc_Call { + _c.Call.Return(run) + return _c +} + // RegisterShutdown provides a mock function with given fields: fn func (_m *MockInitializer) RegisterShutdown(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterShutdown") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error); ok { r0 = rf(fn) @@ -2429,10 +8130,42 @@ func (_m *MockInitializer) RegisterShutdown(fn func(context.Context, runtime.Log return r0 } +// MockInitializer_RegisterShutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterShutdown' +type MockInitializer_RegisterShutdown_Call struct { + *mock.Call +} + +// RegisterShutdown is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) +func (_e *MockInitializer_Expecter) RegisterShutdown(fn interface{}) *MockInitializer_RegisterShutdown_Call { + return &MockInitializer_RegisterShutdown_Call{Call: _e.mock.On("RegisterShutdown", fn)} +} + +func (_c *MockInitializer_RegisterShutdown_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule))) *MockInitializer_RegisterShutdown_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule))) + }) + return _c +} + +func (_c *MockInitializer_RegisterShutdown_Call) Return(_a0 error) *MockInitializer_RegisterShutdown_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterShutdown_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error) *MockInitializer_RegisterShutdown_Call { + _c.Call.Return(run) + return _c +} + // RegisterStorageIndex provides a mock function with given fields: name, collection, key, fields, sortableFields, maxEntries, indexOnly func (_m *MockInitializer) RegisterStorageIndex(name string, collection string, key string, fields []string, sortableFields []string, maxEntries int, indexOnly bool) error { ret := _m.Called(name, collection, key, fields, sortableFields, maxEntries, indexOnly) + if len(ret) == 0 { + panic("no return value specified for RegisterStorageIndex") + } + var r0 error if rf, ok := ret.Get(0).(func(string, string, string, []string, []string, int, bool) error); ok { r0 = rf(name, collection, key, fields, sortableFields, maxEntries, indexOnly) @@ -2443,10 +8176,48 @@ func (_m *MockInitializer) RegisterStorageIndex(name string, collection string, return r0 } +// MockInitializer_RegisterStorageIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterStorageIndex' +type MockInitializer_RegisterStorageIndex_Call struct { + *mock.Call +} + +// RegisterStorageIndex is a helper method to define mock.On call +// - name string +// - collection string +// - key string +// - fields []string +// - sortableFields []string +// - maxEntries int +// - indexOnly bool +func (_e *MockInitializer_Expecter) RegisterStorageIndex(name interface{}, collection interface{}, key interface{}, fields interface{}, sortableFields interface{}, maxEntries interface{}, indexOnly interface{}) *MockInitializer_RegisterStorageIndex_Call { + return &MockInitializer_RegisterStorageIndex_Call{Call: _e.mock.On("RegisterStorageIndex", name, collection, key, fields, sortableFields, maxEntries, indexOnly)} +} + +func (_c *MockInitializer_RegisterStorageIndex_Call) Run(run func(name string, collection string, key string, fields []string, sortableFields []string, maxEntries int, indexOnly bool)) *MockInitializer_RegisterStorageIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].([]string), args[5].(int), args[6].(bool)) + }) + return _c +} + +func (_c *MockInitializer_RegisterStorageIndex_Call) Return(_a0 error) *MockInitializer_RegisterStorageIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterStorageIndex_Call) RunAndReturn(run func(string, string, string, []string, []string, int, bool) error) *MockInitializer_RegisterStorageIndex_Call { + _c.Call.Return(run) + return _c +} + // RegisterStorageIndexFilter provides a mock function with given fields: indexName, fn func (_m *MockInitializer) RegisterStorageIndexFilter(indexName string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error { ret := _m.Called(indexName, fn) + if len(ret) == 0 { + panic("no return value specified for RegisterStorageIndexFilter") + } + var r0 error if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error); ok { r0 = rf(indexName, fn) @@ -2457,10 +8228,43 @@ func (_m *MockInitializer) RegisterStorageIndexFilter(indexName string, fn func( return r0 } +// MockInitializer_RegisterStorageIndexFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterStorageIndexFilter' +type MockInitializer_RegisterStorageIndexFilter_Call struct { + *mock.Call +} + +// RegisterStorageIndexFilter is a helper method to define mock.On call +// - indexName string +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *runtime.StorageWrite) bool +func (_e *MockInitializer_Expecter) RegisterStorageIndexFilter(indexName interface{}, fn interface{}) *MockInitializer_RegisterStorageIndexFilter_Call { + return &MockInitializer_RegisterStorageIndexFilter_Call{Call: _e.mock.On("RegisterStorageIndexFilter", indexName, fn)} +} + +func (_c *MockInitializer_RegisterStorageIndexFilter_Call) Run(run func(indexName string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool)) *MockInitializer_RegisterStorageIndexFilter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool)) + }) + return _c +} + +func (_c *MockInitializer_RegisterStorageIndexFilter_Call) Return(_a0 error) *MockInitializer_RegisterStorageIndexFilter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterStorageIndexFilter_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error) *MockInitializer_RegisterStorageIndexFilter_Call { + _c.Call.Return(run) + return _c +} + // RegisterSubscriptionNotificationApple provides a mock function with given fields: fn func (_m *MockInitializer) RegisterSubscriptionNotificationApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterSubscriptionNotificationApple") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error); ok { r0 = rf(fn) @@ -2471,10 +8275,42 @@ func (_m *MockInitializer) RegisterSubscriptionNotificationApple(fn func(context return r0 } +// MockInitializer_RegisterSubscriptionNotificationApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterSubscriptionNotificationApple' +type MockInitializer_RegisterSubscriptionNotificationApple_Call struct { + *mock.Call +} + +// RegisterSubscriptionNotificationApple is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , string) error +func (_e *MockInitializer_Expecter) RegisterSubscriptionNotificationApple(fn interface{}) *MockInitializer_RegisterSubscriptionNotificationApple_Call { + return &MockInitializer_RegisterSubscriptionNotificationApple_Call{Call: _e.mock.On("RegisterSubscriptionNotificationApple", fn)} +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) *MockInitializer_RegisterSubscriptionNotificationApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) Return(_a0 error) *MockInitializer_RegisterSubscriptionNotificationApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error) *MockInitializer_RegisterSubscriptionNotificationApple_Call { + _c.Call.Return(run) + return _c +} + // RegisterSubscriptionNotificationGoogle provides a mock function with given fields: fn func (_m *MockInitializer) RegisterSubscriptionNotificationGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterSubscriptionNotificationGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error); ok { r0 = rf(fn) @@ -2485,10 +8321,42 @@ func (_m *MockInitializer) RegisterSubscriptionNotificationGoogle(fn func(contex return r0 } +// MockInitializer_RegisterSubscriptionNotificationGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterSubscriptionNotificationGoogle' +type MockInitializer_RegisterSubscriptionNotificationGoogle_Call struct { + *mock.Call +} + +// RegisterSubscriptionNotificationGoogle is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , string) error +func (_e *MockInitializer_Expecter) RegisterSubscriptionNotificationGoogle(fn interface{}) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call { + return &MockInitializer_RegisterSubscriptionNotificationGoogle_Call{Call: _e.mock.On("RegisterSubscriptionNotificationGoogle", fn)} +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) Return(_a0 error) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call { + _c.Call.Return(run) + return _c +} + // RegisterTournamentEnd provides a mock function with given fields: fn func (_m *MockInitializer) RegisterTournamentEnd(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterTournamentEnd") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error); ok { r0 = rf(fn) @@ -2499,10 +8367,42 @@ func (_m *MockInitializer) RegisterTournamentEnd(fn func(context.Context, runtim return r0 } +// MockInitializer_RegisterTournamentEnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTournamentEnd' +type MockInitializer_RegisterTournamentEnd_Call struct { + *mock.Call +} + +// RegisterTournamentEnd is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Tournament , int64 , int64) error +func (_e *MockInitializer_Expecter) RegisterTournamentEnd(fn interface{}) *MockInitializer_RegisterTournamentEnd_Call { + return &MockInitializer_RegisterTournamentEnd_Call{Call: _e.mock.On("RegisterTournamentEnd", fn)} +} + +func (_c *MockInitializer_RegisterTournamentEnd_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) *MockInitializer_RegisterTournamentEnd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterTournamentEnd_Call) Return(_a0 error) *MockInitializer_RegisterTournamentEnd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterTournamentEnd_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error) *MockInitializer_RegisterTournamentEnd_Call { + _c.Call.Return(run) + return _c +} + // RegisterTournamentReset provides a mock function with given fields: fn func (_m *MockInitializer) RegisterTournamentReset(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error { ret := _m.Called(fn) + if len(ret) == 0 { + panic("no return value specified for RegisterTournamentReset") + } + var r0 error if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error); ok { r0 = rf(fn) @@ -2513,13 +8413,40 @@ func (_m *MockInitializer) RegisterTournamentReset(fn func(context.Context, runt return r0 } -type mockConstructorTestingTNewMockInitializer interface { - mock.TestingT - Cleanup(func()) +// MockInitializer_RegisterTournamentReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTournamentReset' +type MockInitializer_RegisterTournamentReset_Call struct { + *mock.Call +} + +// RegisterTournamentReset is a helper method to define mock.On call +// - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Tournament , int64 , int64) error +func (_e *MockInitializer_Expecter) RegisterTournamentReset(fn interface{}) *MockInitializer_RegisterTournamentReset_Call { + return &MockInitializer_RegisterTournamentReset_Call{Call: _e.mock.On("RegisterTournamentReset", fn)} +} + +func (_c *MockInitializer_RegisterTournamentReset_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) *MockInitializer_RegisterTournamentReset_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) + }) + return _c +} + +func (_c *MockInitializer_RegisterTournamentReset_Call) Return(_a0 error) *MockInitializer_RegisterTournamentReset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockInitializer_RegisterTournamentReset_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error) *MockInitializer_RegisterTournamentReset_Call { + _c.Call.Return(run) + return _c } // NewMockInitializer creates a new instance of MockInitializer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockInitializer(t mockConstructorTestingTNewMockInitializer) *MockInitializer { +// The first argument is typically a *testing.T value. +func NewMockInitializer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockInitializer { mock := &MockInitializer{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_Logger.go b/relay/nakama/mocks/mock_Logger.go index c8ec45506..7962c5618 100644 --- a/relay/nakama/mocks/mock_Logger.go +++ b/relay/nakama/mocks/mock_Logger.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,6 +12,14 @@ type MockLogger struct { mock.Mock } +type MockLogger_Expecter struct { + mock *mock.Mock +} + +func (_m *MockLogger) EXPECT() *MockLogger_Expecter { + return &MockLogger_Expecter{mock: &_m.Mock} +} + // Debug provides a mock function with given fields: format, v func (_m *MockLogger) Debug(format string, v ...interface{}) { var _ca []interface{} @@ -20,6 +28,42 @@ func (_m *MockLogger) Debug(format string, v ...interface{}) { _m.Called(_ca...) } +// MockLogger_Debug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debug' +type MockLogger_Debug_Call struct { + *mock.Call +} + +// Debug is a helper method to define mock.On call +// - format string +// - v ...interface{} +func (_e *MockLogger_Expecter) Debug(format interface{}, v ...interface{}) *MockLogger_Debug_Call { + return &MockLogger_Debug_Call{Call: _e.mock.On("Debug", + append([]interface{}{format}, v...)...)} +} + +func (_c *MockLogger_Debug_Call) Run(run func(format string, v ...interface{})) *MockLogger_Debug_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockLogger_Debug_Call) Return() *MockLogger_Debug_Call { + _c.Call.Return() + return _c +} + +func (_c *MockLogger_Debug_Call) RunAndReturn(run func(string, ...interface{})) *MockLogger_Debug_Call { + _c.Run(run) + return _c +} + // Error provides a mock function with given fields: format, v func (_m *MockLogger) Error(format string, v ...interface{}) { var _ca []interface{} @@ -28,10 +72,50 @@ func (_m *MockLogger) Error(format string, v ...interface{}) { _m.Called(_ca...) } -// Fields provides a mock function with given fields: +// MockLogger_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error' +type MockLogger_Error_Call struct { + *mock.Call +} + +// Error is a helper method to define mock.On call +// - format string +// - v ...interface{} +func (_e *MockLogger_Expecter) Error(format interface{}, v ...interface{}) *MockLogger_Error_Call { + return &MockLogger_Error_Call{Call: _e.mock.On("Error", + append([]interface{}{format}, v...)...)} +} + +func (_c *MockLogger_Error_Call) Run(run func(format string, v ...interface{})) *MockLogger_Error_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockLogger_Error_Call) Return() *MockLogger_Error_Call { + _c.Call.Return() + return _c +} + +func (_c *MockLogger_Error_Call) RunAndReturn(run func(string, ...interface{})) *MockLogger_Error_Call { + _c.Run(run) + return _c +} + +// Fields provides a mock function with no fields func (_m *MockLogger) Fields() map[string]interface{} { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for Fields") + } + var r0 map[string]interface{} if rf, ok := ret.Get(0).(func() map[string]interface{}); ok { r0 = rf() @@ -44,6 +128,33 @@ func (_m *MockLogger) Fields() map[string]interface{} { return r0 } +// MockLogger_Fields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fields' +type MockLogger_Fields_Call struct { + *mock.Call +} + +// Fields is a helper method to define mock.On call +func (_e *MockLogger_Expecter) Fields() *MockLogger_Fields_Call { + return &MockLogger_Fields_Call{Call: _e.mock.On("Fields")} +} + +func (_c *MockLogger_Fields_Call) Run(run func()) *MockLogger_Fields_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockLogger_Fields_Call) Return(_a0 map[string]interface{}) *MockLogger_Fields_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockLogger_Fields_Call) RunAndReturn(run func() map[string]interface{}) *MockLogger_Fields_Call { + _c.Call.Return(run) + return _c +} + // Info provides a mock function with given fields: format, v func (_m *MockLogger) Info(format string, v ...interface{}) { var _ca []interface{} @@ -52,6 +163,42 @@ func (_m *MockLogger) Info(format string, v ...interface{}) { _m.Called(_ca...) } +// MockLogger_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info' +type MockLogger_Info_Call struct { + *mock.Call +} + +// Info is a helper method to define mock.On call +// - format string +// - v ...interface{} +func (_e *MockLogger_Expecter) Info(format interface{}, v ...interface{}) *MockLogger_Info_Call { + return &MockLogger_Info_Call{Call: _e.mock.On("Info", + append([]interface{}{format}, v...)...)} +} + +func (_c *MockLogger_Info_Call) Run(run func(format string, v ...interface{})) *MockLogger_Info_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockLogger_Info_Call) Return() *MockLogger_Info_Call { + _c.Call.Return() + return _c +} + +func (_c *MockLogger_Info_Call) RunAndReturn(run func(string, ...interface{})) *MockLogger_Info_Call { + _c.Run(run) + return _c +} + // Warn provides a mock function with given fields: format, v func (_m *MockLogger) Warn(format string, v ...interface{}) { var _ca []interface{} @@ -60,10 +207,50 @@ func (_m *MockLogger) Warn(format string, v ...interface{}) { _m.Called(_ca...) } +// MockLogger_Warn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warn' +type MockLogger_Warn_Call struct { + *mock.Call +} + +// Warn is a helper method to define mock.On call +// - format string +// - v ...interface{} +func (_e *MockLogger_Expecter) Warn(format interface{}, v ...interface{}) *MockLogger_Warn_Call { + return &MockLogger_Warn_Call{Call: _e.mock.On("Warn", + append([]interface{}{format}, v...)...)} +} + +func (_c *MockLogger_Warn_Call) Run(run func(format string, v ...interface{})) *MockLogger_Warn_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockLogger_Warn_Call) Return() *MockLogger_Warn_Call { + _c.Call.Return() + return _c +} + +func (_c *MockLogger_Warn_Call) RunAndReturn(run func(string, ...interface{})) *MockLogger_Warn_Call { + _c.Run(run) + return _c +} + // WithField provides a mock function with given fields: key, v func (_m *MockLogger) WithField(key string, v interface{}) runtime.Logger { ret := _m.Called(key, v) + if len(ret) == 0 { + panic("no return value specified for WithField") + } + var r0 runtime.Logger if rf, ok := ret.Get(0).(func(string, interface{}) runtime.Logger); ok { r0 = rf(key, v) @@ -76,10 +263,43 @@ func (_m *MockLogger) WithField(key string, v interface{}) runtime.Logger { return r0 } +// MockLogger_WithField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithField' +type MockLogger_WithField_Call struct { + *mock.Call +} + +// WithField is a helper method to define mock.On call +// - key string +// - v interface{} +func (_e *MockLogger_Expecter) WithField(key interface{}, v interface{}) *MockLogger_WithField_Call { + return &MockLogger_WithField_Call{Call: _e.mock.On("WithField", key, v)} +} + +func (_c *MockLogger_WithField_Call) Run(run func(key string, v interface{})) *MockLogger_WithField_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(interface{})) + }) + return _c +} + +func (_c *MockLogger_WithField_Call) Return(_a0 runtime.Logger) *MockLogger_WithField_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockLogger_WithField_Call) RunAndReturn(run func(string, interface{}) runtime.Logger) *MockLogger_WithField_Call { + _c.Call.Return(run) + return _c +} + // WithFields provides a mock function with given fields: fields func (_m *MockLogger) WithFields(fields map[string]interface{}) runtime.Logger { ret := _m.Called(fields) + if len(ret) == 0 { + panic("no return value specified for WithFields") + } + var r0 runtime.Logger if rf, ok := ret.Get(0).(func(map[string]interface{}) runtime.Logger); ok { r0 = rf(fields) @@ -92,13 +312,40 @@ func (_m *MockLogger) WithFields(fields map[string]interface{}) runtime.Logger { return r0 } -type mockConstructorTestingTNewMockLogger interface { - mock.TestingT - Cleanup(func()) +// MockLogger_WithFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithFields' +type MockLogger_WithFields_Call struct { + *mock.Call +} + +// WithFields is a helper method to define mock.On call +// - fields map[string]interface{} +func (_e *MockLogger_Expecter) WithFields(fields interface{}) *MockLogger_WithFields_Call { + return &MockLogger_WithFields_Call{Call: _e.mock.On("WithFields", fields)} +} + +func (_c *MockLogger_WithFields_Call) Run(run func(fields map[string]interface{})) *MockLogger_WithFields_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]interface{})) + }) + return _c +} + +func (_c *MockLogger_WithFields_Call) Return(_a0 runtime.Logger) *MockLogger_WithFields_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockLogger_WithFields_Call) RunAndReturn(run func(map[string]interface{}) runtime.Logger) *MockLogger_WithFields_Call { + _c.Call.Return(run) + return _c } // NewMockLogger creates a new instance of MockLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockLogger(t mockConstructorTestingTNewMockLogger) *MockLogger { +// The first argument is typically a *testing.T value. +func NewMockLogger(t interface { + mock.TestingT + Cleanup(func()) +}) *MockLogger { mock := &MockLogger{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_LoggerConfig.go b/relay/nakama/mocks/mock_LoggerConfig.go new file mode 100644 index 000000000..c767db9e3 --- /dev/null +++ b/relay/nakama/mocks/mock_LoggerConfig.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockLoggerConfig is an autogenerated mock type for the LoggerConfig type +type MockLoggerConfig struct { + mock.Mock +} + +type MockLoggerConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockLoggerConfig) EXPECT() *MockLoggerConfig_Expecter { + return &MockLoggerConfig_Expecter{mock: &_m.Mock} +} + +// GetLevel provides a mock function with no fields +func (_m *MockLoggerConfig) GetLevel() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetLevel") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockLoggerConfig_GetLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLevel' +type MockLoggerConfig_GetLevel_Call struct { + *mock.Call +} + +// GetLevel is a helper method to define mock.On call +func (_e *MockLoggerConfig_Expecter) GetLevel() *MockLoggerConfig_GetLevel_Call { + return &MockLoggerConfig_GetLevel_Call{Call: _e.mock.On("GetLevel")} +} + +func (_c *MockLoggerConfig_GetLevel_Call) Run(run func()) *MockLoggerConfig_GetLevel_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockLoggerConfig_GetLevel_Call) Return(_a0 string) *MockLoggerConfig_GetLevel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockLoggerConfig_GetLevel_Call) RunAndReturn(run func() string) *MockLoggerConfig_GetLevel_Call { + _c.Call.Return(run) + return _c +} + +// NewMockLoggerConfig creates a new instance of MockLoggerConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockLoggerConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockLoggerConfig { + mock := &MockLoggerConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_Match.go b/relay/nakama/mocks/mock_Match.go index 6cb2b682a..9826fbd2f 100644 --- a/relay/nakama/mocks/mock_Match.go +++ b/relay/nakama/mocks/mock_Match.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -16,10 +16,22 @@ type MockMatch struct { mock.Mock } +type MockMatch_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMatch) EXPECT() *MockMatch_Expecter { + return &MockMatch_Expecter{mock: &_m.Mock} +} + // MatchInit provides a mock function with given fields: ctx, logger, db, nk, params func (_m *MockMatch) MatchInit(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, params map[string]interface{}) (interface{}, int, string) { ret := _m.Called(ctx, logger, db, nk, params) + if len(ret) == 0 { + panic("no return value specified for MatchInit") + } + var r0 interface{} var r1 int var r2 string @@ -49,10 +61,46 @@ func (_m *MockMatch) MatchInit(ctx context.Context, logger runtime.Logger, db *s return r0, r1, r2 } +// MockMatch_MatchInit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchInit' +type MockMatch_MatchInit_Call struct { + *mock.Call +} + +// MatchInit is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - params map[string]interface{} +func (_e *MockMatch_Expecter) MatchInit(ctx interface{}, logger interface{}, db interface{}, nk interface{}, params interface{}) *MockMatch_MatchInit_Call { + return &MockMatch_MatchInit_Call{Call: _e.mock.On("MatchInit", ctx, logger, db, nk, params)} +} + +func (_c *MockMatch_MatchInit_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, params map[string]interface{})) *MockMatch_MatchInit_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(map[string]interface{})) + }) + return _c +} + +func (_c *MockMatch_MatchInit_Call) Return(_a0 interface{}, _a1 int, _a2 string) *MockMatch_MatchInit_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockMatch_MatchInit_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, map[string]interface{}) (interface{}, int, string)) *MockMatch_MatchInit_Call { + _c.Call.Return(run) + return _c +} + // MatchJoin provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, presences func (_m *MockMatch) MatchJoin(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence) interface{} { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, presences) + if len(ret) == 0 { + panic("no return value specified for MatchJoin") + } + var r0 interface{} if rf, ok := ret.Get(0).(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.Presence) interface{}); ok { r0 = rf(ctx, logger, db, nk, dispatcher, tick, state, presences) @@ -65,10 +113,49 @@ func (_m *MockMatch) MatchJoin(ctx context.Context, logger runtime.Logger, db *s return r0 } +// MockMatch_MatchJoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchJoin' +type MockMatch_MatchJoin_Call struct { + *mock.Call +} + +// MatchJoin is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - presences []runtime.Presence +func (_e *MockMatch_Expecter) MatchJoin(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, presences interface{}) *MockMatch_MatchJoin_Call { + return &MockMatch_MatchJoin_Call{Call: _e.mock.On("MatchJoin", ctx, logger, db, nk, dispatcher, tick, state, presences)} +} + +func (_c *MockMatch_MatchJoin_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence)) *MockMatch_MatchJoin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].([]runtime.Presence)) + }) + return _c +} + +func (_c *MockMatch_MatchJoin_Call) Return(_a0 interface{}) *MockMatch_MatchJoin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatch_MatchJoin_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.Presence) interface{}) *MockMatch_MatchJoin_Call { + _c.Call.Return(run) + return _c +} + // MatchJoinAttempt provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, presence, metadata func (_m *MockMatch) MatchJoinAttempt(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presence runtime.Presence, metadata map[string]string) (interface{}, bool, string) { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, presence, metadata) + if len(ret) == 0 { + panic("no return value specified for MatchJoinAttempt") + } + var r0 interface{} var r1 bool var r2 string @@ -98,10 +185,50 @@ func (_m *MockMatch) MatchJoinAttempt(ctx context.Context, logger runtime.Logger return r0, r1, r2 } +// MockMatch_MatchJoinAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchJoinAttempt' +type MockMatch_MatchJoinAttempt_Call struct { + *mock.Call +} + +// MatchJoinAttempt is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - presence runtime.Presence +// - metadata map[string]string +func (_e *MockMatch_Expecter) MatchJoinAttempt(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, presence interface{}, metadata interface{}) *MockMatch_MatchJoinAttempt_Call { + return &MockMatch_MatchJoinAttempt_Call{Call: _e.mock.On("MatchJoinAttempt", ctx, logger, db, nk, dispatcher, tick, state, presence, metadata)} +} + +func (_c *MockMatch_MatchJoinAttempt_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presence runtime.Presence, metadata map[string]string)) *MockMatch_MatchJoinAttempt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].(runtime.Presence), args[8].(map[string]string)) + }) + return _c +} + +func (_c *MockMatch_MatchJoinAttempt_Call) Return(_a0 interface{}, _a1 bool, _a2 string) *MockMatch_MatchJoinAttempt_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockMatch_MatchJoinAttempt_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, runtime.Presence, map[string]string) (interface{}, bool, string)) *MockMatch_MatchJoinAttempt_Call { + _c.Call.Return(run) + return _c +} + // MatchLeave provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, presences func (_m *MockMatch) MatchLeave(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence) interface{} { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, presences) + if len(ret) == 0 { + panic("no return value specified for MatchLeave") + } + var r0 interface{} if rf, ok := ret.Get(0).(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.Presence) interface{}); ok { r0 = rf(ctx, logger, db, nk, dispatcher, tick, state, presences) @@ -114,10 +241,49 @@ func (_m *MockMatch) MatchLeave(ctx context.Context, logger runtime.Logger, db * return r0 } +// MockMatch_MatchLeave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchLeave' +type MockMatch_MatchLeave_Call struct { + *mock.Call +} + +// MatchLeave is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - presences []runtime.Presence +func (_e *MockMatch_Expecter) MatchLeave(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, presences interface{}) *MockMatch_MatchLeave_Call { + return &MockMatch_MatchLeave_Call{Call: _e.mock.On("MatchLeave", ctx, logger, db, nk, dispatcher, tick, state, presences)} +} + +func (_c *MockMatch_MatchLeave_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, presences []runtime.Presence)) *MockMatch_MatchLeave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].([]runtime.Presence)) + }) + return _c +} + +func (_c *MockMatch_MatchLeave_Call) Return(_a0 interface{}) *MockMatch_MatchLeave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatch_MatchLeave_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.Presence) interface{}) *MockMatch_MatchLeave_Call { + _c.Call.Return(run) + return _c +} + // MatchLoop provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, messages func (_m *MockMatch) MatchLoop(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, messages []runtime.MatchData) interface{} { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, messages) + if len(ret) == 0 { + panic("no return value specified for MatchLoop") + } + var r0 interface{} if rf, ok := ret.Get(0).(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.MatchData) interface{}); ok { r0 = rf(ctx, logger, db, nk, dispatcher, tick, state, messages) @@ -130,10 +296,49 @@ func (_m *MockMatch) MatchLoop(ctx context.Context, logger runtime.Logger, db *s return r0 } +// MockMatch_MatchLoop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchLoop' +type MockMatch_MatchLoop_Call struct { + *mock.Call +} + +// MatchLoop is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - messages []runtime.MatchData +func (_e *MockMatch_Expecter) MatchLoop(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, messages interface{}) *MockMatch_MatchLoop_Call { + return &MockMatch_MatchLoop_Call{Call: _e.mock.On("MatchLoop", ctx, logger, db, nk, dispatcher, tick, state, messages)} +} + +func (_c *MockMatch_MatchLoop_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, messages []runtime.MatchData)) *MockMatch_MatchLoop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].([]runtime.MatchData)) + }) + return _c +} + +func (_c *MockMatch_MatchLoop_Call) Return(_a0 interface{}) *MockMatch_MatchLoop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatch_MatchLoop_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, []runtime.MatchData) interface{}) *MockMatch_MatchLoop_Call { + _c.Call.Return(run) + return _c +} + // MatchSignal provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, data func (_m *MockMatch) MatchSignal(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, data string) (interface{}, string) { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, data) + if len(ret) == 0 { + panic("no return value specified for MatchSignal") + } + var r0 interface{} var r1 string if rf, ok := ret.Get(0).(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, string) (interface{}, string)); ok { @@ -156,10 +361,49 @@ func (_m *MockMatch) MatchSignal(ctx context.Context, logger runtime.Logger, db return r0, r1 } +// MockMatch_MatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchSignal' +type MockMatch_MatchSignal_Call struct { + *mock.Call +} + +// MatchSignal is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - data string +func (_e *MockMatch_Expecter) MatchSignal(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, data interface{}) *MockMatch_MatchSignal_Call { + return &MockMatch_MatchSignal_Call{Call: _e.mock.On("MatchSignal", ctx, logger, db, nk, dispatcher, tick, state, data)} +} + +func (_c *MockMatch_MatchSignal_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, data string)) *MockMatch_MatchSignal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].(string)) + }) + return _c +} + +func (_c *MockMatch_MatchSignal_Call) Return(_a0 interface{}, _a1 string) *MockMatch_MatchSignal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockMatch_MatchSignal_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, string) (interface{}, string)) *MockMatch_MatchSignal_Call { + _c.Call.Return(run) + return _c +} + // MatchTerminate provides a mock function with given fields: ctx, logger, db, nk, dispatcher, tick, state, graceSeconds func (_m *MockMatch) MatchTerminate(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, graceSeconds int) interface{} { ret := _m.Called(ctx, logger, db, nk, dispatcher, tick, state, graceSeconds) + if len(ret) == 0 { + panic("no return value specified for MatchTerminate") + } + var r0 interface{} if rf, ok := ret.Get(0).(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, int) interface{}); ok { r0 = rf(ctx, logger, db, nk, dispatcher, tick, state, graceSeconds) @@ -172,13 +416,47 @@ func (_m *MockMatch) MatchTerminate(ctx context.Context, logger runtime.Logger, return r0 } -type mockConstructorTestingTNewMockMatch interface { - mock.TestingT - Cleanup(func()) +// MockMatch_MatchTerminate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchTerminate' +type MockMatch_MatchTerminate_Call struct { + *mock.Call +} + +// MatchTerminate is a helper method to define mock.On call +// - ctx context.Context +// - logger runtime.Logger +// - db *sql.DB +// - nk runtime.NakamaModule +// - dispatcher runtime.MatchDispatcher +// - tick int64 +// - state interface{} +// - graceSeconds int +func (_e *MockMatch_Expecter) MatchTerminate(ctx interface{}, logger interface{}, db interface{}, nk interface{}, dispatcher interface{}, tick interface{}, state interface{}, graceSeconds interface{}) *MockMatch_MatchTerminate_Call { + return &MockMatch_MatchTerminate_Call{Call: _e.mock.On("MatchTerminate", ctx, logger, db, nk, dispatcher, tick, state, graceSeconds)} +} + +func (_c *MockMatch_MatchTerminate_Call) Run(run func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, dispatcher runtime.MatchDispatcher, tick int64, state interface{}, graceSeconds int)) *MockMatch_MatchTerminate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(runtime.Logger), args[2].(*sql.DB), args[3].(runtime.NakamaModule), args[4].(runtime.MatchDispatcher), args[5].(int64), args[6].(interface{}), args[7].(int)) + }) + return _c +} + +func (_c *MockMatch_MatchTerminate_Call) Return(_a0 interface{}) *MockMatch_MatchTerminate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatch_MatchTerminate_Call) RunAndReturn(run func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, runtime.MatchDispatcher, int64, interface{}, int) interface{}) *MockMatch_MatchTerminate_Call { + _c.Call.Return(run) + return _c } // NewMockMatch creates a new instance of MockMatch. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockMatch(t mockConstructorTestingTNewMockMatch) *MockMatch { +// The first argument is typically a *testing.T value. +func NewMockMatch(t interface { + mock.TestingT + Cleanup(func()) +}) *MockMatch { mock := &MockMatch{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_MatchData.go b/relay/nakama/mocks/mock_MatchData.go index b1958969b..ac2b6706b 100644 --- a/relay/nakama/mocks/mock_MatchData.go +++ b/relay/nakama/mocks/mock_MatchData.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockMatchData struct { mock.Mock } -// GetData provides a mock function with given fields: +type MockMatchData_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMatchData) EXPECT() *MockMatchData_Expecter { + return &MockMatchData_Expecter{mock: &_m.Mock} +} + +// GetData provides a mock function with no fields func (_m *MockMatchData) GetData() []byte { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetData") + } + var r0 []byte if rf, ok := ret.Get(0).(func() []byte); ok { r0 = rf() @@ -28,10 +40,41 @@ func (_m *MockMatchData) GetData() []byte { return r0 } -// GetHidden provides a mock function with given fields: +// MockMatchData_GetData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetData' +type MockMatchData_GetData_Call struct { + *mock.Call +} + +// GetData is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetData() *MockMatchData_GetData_Call { + return &MockMatchData_GetData_Call{Call: _e.mock.On("GetData")} +} + +func (_c *MockMatchData_GetData_Call) Run(run func()) *MockMatchData_GetData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetData_Call) Return(_a0 []byte) *MockMatchData_GetData_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetData_Call) RunAndReturn(run func() []byte) *MockMatchData_GetData_Call { + _c.Call.Return(run) + return _c +} + +// GetHidden provides a mock function with no fields func (_m *MockMatchData) GetHidden() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetHidden") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -42,10 +85,41 @@ func (_m *MockMatchData) GetHidden() bool { return r0 } -// GetNodeId provides a mock function with given fields: +// MockMatchData_GetHidden_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHidden' +type MockMatchData_GetHidden_Call struct { + *mock.Call +} + +// GetHidden is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetHidden() *MockMatchData_GetHidden_Call { + return &MockMatchData_GetHidden_Call{Call: _e.mock.On("GetHidden")} +} + +func (_c *MockMatchData_GetHidden_Call) Run(run func()) *MockMatchData_GetHidden_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetHidden_Call) Return(_a0 bool) *MockMatchData_GetHidden_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetHidden_Call) RunAndReturn(run func() bool) *MockMatchData_GetHidden_Call { + _c.Call.Return(run) + return _c +} + +// GetNodeId provides a mock function with no fields func (_m *MockMatchData) GetNodeId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetNodeId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -56,10 +130,41 @@ func (_m *MockMatchData) GetNodeId() string { return r0 } -// GetOpCode provides a mock function with given fields: +// MockMatchData_GetNodeId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeId' +type MockMatchData_GetNodeId_Call struct { + *mock.Call +} + +// GetNodeId is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetNodeId() *MockMatchData_GetNodeId_Call { + return &MockMatchData_GetNodeId_Call{Call: _e.mock.On("GetNodeId")} +} + +func (_c *MockMatchData_GetNodeId_Call) Run(run func()) *MockMatchData_GetNodeId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetNodeId_Call) Return(_a0 string) *MockMatchData_GetNodeId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetNodeId_Call) RunAndReturn(run func() string) *MockMatchData_GetNodeId_Call { + _c.Call.Return(run) + return _c +} + +// GetOpCode provides a mock function with no fields func (_m *MockMatchData) GetOpCode() int64 { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetOpCode") + } + var r0 int64 if rf, ok := ret.Get(0).(func() int64); ok { r0 = rf() @@ -70,10 +175,41 @@ func (_m *MockMatchData) GetOpCode() int64 { return r0 } -// GetPersistence provides a mock function with given fields: +// MockMatchData_GetOpCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOpCode' +type MockMatchData_GetOpCode_Call struct { + *mock.Call +} + +// GetOpCode is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetOpCode() *MockMatchData_GetOpCode_Call { + return &MockMatchData_GetOpCode_Call{Call: _e.mock.On("GetOpCode")} +} + +func (_c *MockMatchData_GetOpCode_Call) Run(run func()) *MockMatchData_GetOpCode_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetOpCode_Call) Return(_a0 int64) *MockMatchData_GetOpCode_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetOpCode_Call) RunAndReturn(run func() int64) *MockMatchData_GetOpCode_Call { + _c.Call.Return(run) + return _c +} + +// GetPersistence provides a mock function with no fields func (_m *MockMatchData) GetPersistence() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetPersistence") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -84,10 +220,41 @@ func (_m *MockMatchData) GetPersistence() bool { return r0 } -// GetReason provides a mock function with given fields: +// MockMatchData_GetPersistence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPersistence' +type MockMatchData_GetPersistence_Call struct { + *mock.Call +} + +// GetPersistence is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetPersistence() *MockMatchData_GetPersistence_Call { + return &MockMatchData_GetPersistence_Call{Call: _e.mock.On("GetPersistence")} +} + +func (_c *MockMatchData_GetPersistence_Call) Run(run func()) *MockMatchData_GetPersistence_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetPersistence_Call) Return(_a0 bool) *MockMatchData_GetPersistence_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetPersistence_Call) RunAndReturn(run func() bool) *MockMatchData_GetPersistence_Call { + _c.Call.Return(run) + return _c +} + +// GetReason provides a mock function with no fields func (_m *MockMatchData) GetReason() runtime.PresenceReason { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetReason") + } + var r0 runtime.PresenceReason if rf, ok := ret.Get(0).(func() runtime.PresenceReason); ok { r0 = rf() @@ -98,10 +265,41 @@ func (_m *MockMatchData) GetReason() runtime.PresenceReason { return r0 } -// GetReceiveTime provides a mock function with given fields: +// MockMatchData_GetReason_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReason' +type MockMatchData_GetReason_Call struct { + *mock.Call +} + +// GetReason is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetReason() *MockMatchData_GetReason_Call { + return &MockMatchData_GetReason_Call{Call: _e.mock.On("GetReason")} +} + +func (_c *MockMatchData_GetReason_Call) Run(run func()) *MockMatchData_GetReason_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetReason_Call) Return(_a0 runtime.PresenceReason) *MockMatchData_GetReason_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetReason_Call) RunAndReturn(run func() runtime.PresenceReason) *MockMatchData_GetReason_Call { + _c.Call.Return(run) + return _c +} + +// GetReceiveTime provides a mock function with no fields func (_m *MockMatchData) GetReceiveTime() int64 { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetReceiveTime") + } + var r0 int64 if rf, ok := ret.Get(0).(func() int64); ok { r0 = rf() @@ -112,10 +310,41 @@ func (_m *MockMatchData) GetReceiveTime() int64 { return r0 } -// GetReliable provides a mock function with given fields: +// MockMatchData_GetReceiveTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReceiveTime' +type MockMatchData_GetReceiveTime_Call struct { + *mock.Call +} + +// GetReceiveTime is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetReceiveTime() *MockMatchData_GetReceiveTime_Call { + return &MockMatchData_GetReceiveTime_Call{Call: _e.mock.On("GetReceiveTime")} +} + +func (_c *MockMatchData_GetReceiveTime_Call) Run(run func()) *MockMatchData_GetReceiveTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetReceiveTime_Call) Return(_a0 int64) *MockMatchData_GetReceiveTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetReceiveTime_Call) RunAndReturn(run func() int64) *MockMatchData_GetReceiveTime_Call { + _c.Call.Return(run) + return _c +} + +// GetReliable provides a mock function with no fields func (_m *MockMatchData) GetReliable() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetReliable") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -126,10 +355,41 @@ func (_m *MockMatchData) GetReliable() bool { return r0 } -// GetSessionId provides a mock function with given fields: +// MockMatchData_GetReliable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReliable' +type MockMatchData_GetReliable_Call struct { + *mock.Call +} + +// GetReliable is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetReliable() *MockMatchData_GetReliable_Call { + return &MockMatchData_GetReliable_Call{Call: _e.mock.On("GetReliable")} +} + +func (_c *MockMatchData_GetReliable_Call) Run(run func()) *MockMatchData_GetReliable_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetReliable_Call) Return(_a0 bool) *MockMatchData_GetReliable_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetReliable_Call) RunAndReturn(run func() bool) *MockMatchData_GetReliable_Call { + _c.Call.Return(run) + return _c +} + +// GetSessionId provides a mock function with no fields func (_m *MockMatchData) GetSessionId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetSessionId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -140,10 +400,41 @@ func (_m *MockMatchData) GetSessionId() string { return r0 } -// GetStatus provides a mock function with given fields: +// MockMatchData_GetSessionId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionId' +type MockMatchData_GetSessionId_Call struct { + *mock.Call +} + +// GetSessionId is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetSessionId() *MockMatchData_GetSessionId_Call { + return &MockMatchData_GetSessionId_Call{Call: _e.mock.On("GetSessionId")} +} + +func (_c *MockMatchData_GetSessionId_Call) Run(run func()) *MockMatchData_GetSessionId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetSessionId_Call) Return(_a0 string) *MockMatchData_GetSessionId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetSessionId_Call) RunAndReturn(run func() string) *MockMatchData_GetSessionId_Call { + _c.Call.Return(run) + return _c +} + +// GetStatus provides a mock function with no fields func (_m *MockMatchData) GetStatus() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetStatus") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -154,10 +445,41 @@ func (_m *MockMatchData) GetStatus() string { return r0 } -// GetUserId provides a mock function with given fields: +// MockMatchData_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus' +type MockMatchData_GetStatus_Call struct { + *mock.Call +} + +// GetStatus is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetStatus() *MockMatchData_GetStatus_Call { + return &MockMatchData_GetStatus_Call{Call: _e.mock.On("GetStatus")} +} + +func (_c *MockMatchData_GetStatus_Call) Run(run func()) *MockMatchData_GetStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetStatus_Call) Return(_a0 string) *MockMatchData_GetStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetStatus_Call) RunAndReturn(run func() string) *MockMatchData_GetStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetUserId provides a mock function with no fields func (_m *MockMatchData) GetUserId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUserId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -168,10 +490,41 @@ func (_m *MockMatchData) GetUserId() string { return r0 } -// GetUsername provides a mock function with given fields: +// MockMatchData_GetUserId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserId' +type MockMatchData_GetUserId_Call struct { + *mock.Call +} + +// GetUserId is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetUserId() *MockMatchData_GetUserId_Call { + return &MockMatchData_GetUserId_Call{Call: _e.mock.On("GetUserId")} +} + +func (_c *MockMatchData_GetUserId_Call) Run(run func()) *MockMatchData_GetUserId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetUserId_Call) Return(_a0 string) *MockMatchData_GetUserId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetUserId_Call) RunAndReturn(run func() string) *MockMatchData_GetUserId_Call { + _c.Call.Return(run) + return _c +} + +// GetUsername provides a mock function with no fields func (_m *MockMatchData) GetUsername() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUsername") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -182,13 +535,39 @@ func (_m *MockMatchData) GetUsername() string { return r0 } -type mockConstructorTestingTNewMockMatchData interface { - mock.TestingT - Cleanup(func()) +// MockMatchData_GetUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsername' +type MockMatchData_GetUsername_Call struct { + *mock.Call +} + +// GetUsername is a helper method to define mock.On call +func (_e *MockMatchData_Expecter) GetUsername() *MockMatchData_GetUsername_Call { + return &MockMatchData_GetUsername_Call{Call: _e.mock.On("GetUsername")} +} + +func (_c *MockMatchData_GetUsername_Call) Run(run func()) *MockMatchData_GetUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchData_GetUsername_Call) Return(_a0 string) *MockMatchData_GetUsername_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchData_GetUsername_Call) RunAndReturn(run func() string) *MockMatchData_GetUsername_Call { + _c.Call.Return(run) + return _c } // NewMockMatchData creates a new instance of MockMatchData. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockMatchData(t mockConstructorTestingTNewMockMatchData) *MockMatchData { +// The first argument is typically a *testing.T value. +func NewMockMatchData(t interface { + mock.TestingT + Cleanup(func()) +}) *MockMatchData { mock := &MockMatchData{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_MatchDispatcher.go b/relay/nakama/mocks/mock_MatchDispatcher.go index e516b3ecc..bec5a5637 100644 --- a/relay/nakama/mocks/mock_MatchDispatcher.go +++ b/relay/nakama/mocks/mock_MatchDispatcher.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockMatchDispatcher struct { mock.Mock } +type MockMatchDispatcher_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMatchDispatcher) EXPECT() *MockMatchDispatcher_Expecter { + return &MockMatchDispatcher_Expecter{mock: &_m.Mock} +} + // BroadcastMessage provides a mock function with given fields: opCode, data, presences, sender, reliable func (_m *MockMatchDispatcher) BroadcastMessage(opCode int64, data []byte, presences []runtime.Presence, sender runtime.Presence, reliable bool) error { ret := _m.Called(opCode, data, presences, sender, reliable) + if len(ret) == 0 { + panic("no return value specified for BroadcastMessage") + } + var r0 error if rf, ok := ret.Get(0).(func(int64, []byte, []runtime.Presence, runtime.Presence, bool) error); ok { r0 = rf(opCode, data, presences, sender, reliable) @@ -26,10 +38,46 @@ func (_m *MockMatchDispatcher) BroadcastMessage(opCode int64, data []byte, prese return r0 } +// MockMatchDispatcher_BroadcastMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastMessage' +type MockMatchDispatcher_BroadcastMessage_Call struct { + *mock.Call +} + +// BroadcastMessage is a helper method to define mock.On call +// - opCode int64 +// - data []byte +// - presences []runtime.Presence +// - sender runtime.Presence +// - reliable bool +func (_e *MockMatchDispatcher_Expecter) BroadcastMessage(opCode interface{}, data interface{}, presences interface{}, sender interface{}, reliable interface{}) *MockMatchDispatcher_BroadcastMessage_Call { + return &MockMatchDispatcher_BroadcastMessage_Call{Call: _e.mock.On("BroadcastMessage", opCode, data, presences, sender, reliable)} +} + +func (_c *MockMatchDispatcher_BroadcastMessage_Call) Run(run func(opCode int64, data []byte, presences []runtime.Presence, sender runtime.Presence, reliable bool)) *MockMatchDispatcher_BroadcastMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int64), args[1].([]byte), args[2].([]runtime.Presence), args[3].(runtime.Presence), args[4].(bool)) + }) + return _c +} + +func (_c *MockMatchDispatcher_BroadcastMessage_Call) Return(_a0 error) *MockMatchDispatcher_BroadcastMessage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchDispatcher_BroadcastMessage_Call) RunAndReturn(run func(int64, []byte, []runtime.Presence, runtime.Presence, bool) error) *MockMatchDispatcher_BroadcastMessage_Call { + _c.Call.Return(run) + return _c +} + // BroadcastMessageDeferred provides a mock function with given fields: opCode, data, presences, sender, reliable func (_m *MockMatchDispatcher) BroadcastMessageDeferred(opCode int64, data []byte, presences []runtime.Presence, sender runtime.Presence, reliable bool) error { ret := _m.Called(opCode, data, presences, sender, reliable) + if len(ret) == 0 { + panic("no return value specified for BroadcastMessageDeferred") + } + var r0 error if rf, ok := ret.Get(0).(func(int64, []byte, []runtime.Presence, runtime.Presence, bool) error); ok { r0 = rf(opCode, data, presences, sender, reliable) @@ -40,10 +88,46 @@ func (_m *MockMatchDispatcher) BroadcastMessageDeferred(opCode int64, data []byt return r0 } +// MockMatchDispatcher_BroadcastMessageDeferred_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastMessageDeferred' +type MockMatchDispatcher_BroadcastMessageDeferred_Call struct { + *mock.Call +} + +// BroadcastMessageDeferred is a helper method to define mock.On call +// - opCode int64 +// - data []byte +// - presences []runtime.Presence +// - sender runtime.Presence +// - reliable bool +func (_e *MockMatchDispatcher_Expecter) BroadcastMessageDeferred(opCode interface{}, data interface{}, presences interface{}, sender interface{}, reliable interface{}) *MockMatchDispatcher_BroadcastMessageDeferred_Call { + return &MockMatchDispatcher_BroadcastMessageDeferred_Call{Call: _e.mock.On("BroadcastMessageDeferred", opCode, data, presences, sender, reliable)} +} + +func (_c *MockMatchDispatcher_BroadcastMessageDeferred_Call) Run(run func(opCode int64, data []byte, presences []runtime.Presence, sender runtime.Presence, reliable bool)) *MockMatchDispatcher_BroadcastMessageDeferred_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int64), args[1].([]byte), args[2].([]runtime.Presence), args[3].(runtime.Presence), args[4].(bool)) + }) + return _c +} + +func (_c *MockMatchDispatcher_BroadcastMessageDeferred_Call) Return(_a0 error) *MockMatchDispatcher_BroadcastMessageDeferred_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchDispatcher_BroadcastMessageDeferred_Call) RunAndReturn(run func(int64, []byte, []runtime.Presence, runtime.Presence, bool) error) *MockMatchDispatcher_BroadcastMessageDeferred_Call { + _c.Call.Return(run) + return _c +} + // MatchKick provides a mock function with given fields: presences func (_m *MockMatchDispatcher) MatchKick(presences []runtime.Presence) error { ret := _m.Called(presences) + if len(ret) == 0 { + panic("no return value specified for MatchKick") + } + var r0 error if rf, ok := ret.Get(0).(func([]runtime.Presence) error); ok { r0 = rf(presences) @@ -54,10 +138,42 @@ func (_m *MockMatchDispatcher) MatchKick(presences []runtime.Presence) error { return r0 } +// MockMatchDispatcher_MatchKick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchKick' +type MockMatchDispatcher_MatchKick_Call struct { + *mock.Call +} + +// MatchKick is a helper method to define mock.On call +// - presences []runtime.Presence +func (_e *MockMatchDispatcher_Expecter) MatchKick(presences interface{}) *MockMatchDispatcher_MatchKick_Call { + return &MockMatchDispatcher_MatchKick_Call{Call: _e.mock.On("MatchKick", presences)} +} + +func (_c *MockMatchDispatcher_MatchKick_Call) Run(run func(presences []runtime.Presence)) *MockMatchDispatcher_MatchKick_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]runtime.Presence)) + }) + return _c +} + +func (_c *MockMatchDispatcher_MatchKick_Call) Return(_a0 error) *MockMatchDispatcher_MatchKick_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchDispatcher_MatchKick_Call) RunAndReturn(run func([]runtime.Presence) error) *MockMatchDispatcher_MatchKick_Call { + _c.Call.Return(run) + return _c +} + // MatchLabelUpdate provides a mock function with given fields: label func (_m *MockMatchDispatcher) MatchLabelUpdate(label string) error { ret := _m.Called(label) + if len(ret) == 0 { + panic("no return value specified for MatchLabelUpdate") + } + var r0 error if rf, ok := ret.Get(0).(func(string) error); ok { r0 = rf(label) @@ -68,13 +184,40 @@ func (_m *MockMatchDispatcher) MatchLabelUpdate(label string) error { return r0 } -type mockConstructorTestingTNewMockMatchDispatcher interface { - mock.TestingT - Cleanup(func()) +// MockMatchDispatcher_MatchLabelUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchLabelUpdate' +type MockMatchDispatcher_MatchLabelUpdate_Call struct { + *mock.Call +} + +// MatchLabelUpdate is a helper method to define mock.On call +// - label string +func (_e *MockMatchDispatcher_Expecter) MatchLabelUpdate(label interface{}) *MockMatchDispatcher_MatchLabelUpdate_Call { + return &MockMatchDispatcher_MatchLabelUpdate_Call{Call: _e.mock.On("MatchLabelUpdate", label)} +} + +func (_c *MockMatchDispatcher_MatchLabelUpdate_Call) Run(run func(label string)) *MockMatchDispatcher_MatchLabelUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockMatchDispatcher_MatchLabelUpdate_Call) Return(_a0 error) *MockMatchDispatcher_MatchLabelUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchDispatcher_MatchLabelUpdate_Call) RunAndReturn(run func(string) error) *MockMatchDispatcher_MatchLabelUpdate_Call { + _c.Call.Return(run) + return _c } // NewMockMatchDispatcher creates a new instance of MockMatchDispatcher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockMatchDispatcher(t mockConstructorTestingTNewMockMatchDispatcher) *MockMatchDispatcher { +// The first argument is typically a *testing.T value. +func NewMockMatchDispatcher(t interface { + mock.TestingT + Cleanup(func()) +}) *MockMatchDispatcher { mock := &MockMatchDispatcher{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_MatchmakerEntry.go b/relay/nakama/mocks/mock_MatchmakerEntry.go index 42a85a39f..02ff24c03 100644 --- a/relay/nakama/mocks/mock_MatchmakerEntry.go +++ b/relay/nakama/mocks/mock_MatchmakerEntry.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockMatchmakerEntry struct { mock.Mock } -// GetPartyId provides a mock function with given fields: +type MockMatchmakerEntry_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMatchmakerEntry) EXPECT() *MockMatchmakerEntry_Expecter { + return &MockMatchmakerEntry_Expecter{mock: &_m.Mock} +} + +// GetPartyId provides a mock function with no fields func (_m *MockMatchmakerEntry) GetPartyId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetPartyId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -26,10 +38,41 @@ func (_m *MockMatchmakerEntry) GetPartyId() string { return r0 } -// GetPresence provides a mock function with given fields: +// MockMatchmakerEntry_GetPartyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartyId' +type MockMatchmakerEntry_GetPartyId_Call struct { + *mock.Call +} + +// GetPartyId is a helper method to define mock.On call +func (_e *MockMatchmakerEntry_Expecter) GetPartyId() *MockMatchmakerEntry_GetPartyId_Call { + return &MockMatchmakerEntry_GetPartyId_Call{Call: _e.mock.On("GetPartyId")} +} + +func (_c *MockMatchmakerEntry_GetPartyId_Call) Run(run func()) *MockMatchmakerEntry_GetPartyId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchmakerEntry_GetPartyId_Call) Return(_a0 string) *MockMatchmakerEntry_GetPartyId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchmakerEntry_GetPartyId_Call) RunAndReturn(run func() string) *MockMatchmakerEntry_GetPartyId_Call { + _c.Call.Return(run) + return _c +} + +// GetPresence provides a mock function with no fields func (_m *MockMatchmakerEntry) GetPresence() runtime.Presence { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetPresence") + } + var r0 runtime.Presence if rf, ok := ret.Get(0).(func() runtime.Presence); ok { r0 = rf() @@ -42,10 +85,41 @@ func (_m *MockMatchmakerEntry) GetPresence() runtime.Presence { return r0 } -// GetProperties provides a mock function with given fields: +// MockMatchmakerEntry_GetPresence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPresence' +type MockMatchmakerEntry_GetPresence_Call struct { + *mock.Call +} + +// GetPresence is a helper method to define mock.On call +func (_e *MockMatchmakerEntry_Expecter) GetPresence() *MockMatchmakerEntry_GetPresence_Call { + return &MockMatchmakerEntry_GetPresence_Call{Call: _e.mock.On("GetPresence")} +} + +func (_c *MockMatchmakerEntry_GetPresence_Call) Run(run func()) *MockMatchmakerEntry_GetPresence_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchmakerEntry_GetPresence_Call) Return(_a0 runtime.Presence) *MockMatchmakerEntry_GetPresence_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchmakerEntry_GetPresence_Call) RunAndReturn(run func() runtime.Presence) *MockMatchmakerEntry_GetPresence_Call { + _c.Call.Return(run) + return _c +} + +// GetProperties provides a mock function with no fields func (_m *MockMatchmakerEntry) GetProperties() map[string]interface{} { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetProperties") + } + var r0 map[string]interface{} if rf, ok := ret.Get(0).(func() map[string]interface{}); ok { r0 = rf() @@ -58,10 +132,41 @@ func (_m *MockMatchmakerEntry) GetProperties() map[string]interface{} { return r0 } -// GetTicket provides a mock function with given fields: +// MockMatchmakerEntry_GetProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProperties' +type MockMatchmakerEntry_GetProperties_Call struct { + *mock.Call +} + +// GetProperties is a helper method to define mock.On call +func (_e *MockMatchmakerEntry_Expecter) GetProperties() *MockMatchmakerEntry_GetProperties_Call { + return &MockMatchmakerEntry_GetProperties_Call{Call: _e.mock.On("GetProperties")} +} + +func (_c *MockMatchmakerEntry_GetProperties_Call) Run(run func()) *MockMatchmakerEntry_GetProperties_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchmakerEntry_GetProperties_Call) Return(_a0 map[string]interface{}) *MockMatchmakerEntry_GetProperties_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchmakerEntry_GetProperties_Call) RunAndReturn(run func() map[string]interface{}) *MockMatchmakerEntry_GetProperties_Call { + _c.Call.Return(run) + return _c +} + +// GetTicket provides a mock function with no fields func (_m *MockMatchmakerEntry) GetTicket() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetTicket") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -72,13 +177,39 @@ func (_m *MockMatchmakerEntry) GetTicket() string { return r0 } -type mockConstructorTestingTNewMockMatchmakerEntry interface { - mock.TestingT - Cleanup(func()) +// MockMatchmakerEntry_GetTicket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTicket' +type MockMatchmakerEntry_GetTicket_Call struct { + *mock.Call +} + +// GetTicket is a helper method to define mock.On call +func (_e *MockMatchmakerEntry_Expecter) GetTicket() *MockMatchmakerEntry_GetTicket_Call { + return &MockMatchmakerEntry_GetTicket_Call{Call: _e.mock.On("GetTicket")} +} + +func (_c *MockMatchmakerEntry_GetTicket_Call) Run(run func()) *MockMatchmakerEntry_GetTicket_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMatchmakerEntry_GetTicket_Call) Return(_a0 string) *MockMatchmakerEntry_GetTicket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMatchmakerEntry_GetTicket_Call) RunAndReturn(run func() string) *MockMatchmakerEntry_GetTicket_Call { + _c.Call.Return(run) + return _c } // NewMockMatchmakerEntry creates a new instance of MockMatchmakerEntry. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockMatchmakerEntry(t mockConstructorTestingTNewMockMatchmakerEntry) *MockMatchmakerEntry { +// The first argument is typically a *testing.T value. +func NewMockMatchmakerEntry(t interface { + mock.TestingT + Cleanup(func()) +}) *MockMatchmakerEntry { mock := &MockMatchmakerEntry{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_NakamaModule.go b/relay/nakama/mocks/mock_NakamaModule.go index c14403936..9d700a11d 100644 --- a/relay/nakama/mocks/mock_NakamaModule.go +++ b/relay/nakama/mocks/mock_NakamaModule.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -23,10 +23,22 @@ type MockNakamaModule struct { mock.Mock } +type MockNakamaModule_Expecter struct { + mock *mock.Mock +} + +func (_m *MockNakamaModule) EXPECT() *MockNakamaModule_Expecter { + return &MockNakamaModule_Expecter{mock: &_m.Mock} +} + // AccountDeleteId provides a mock function with given fields: ctx, userID, recorded func (_m *MockNakamaModule) AccountDeleteId(ctx context.Context, userID string, recorded bool) error { ret := _m.Called(ctx, userID, recorded) + if len(ret) == 0 { + panic("no return value specified for AccountDeleteId") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, bool) error); ok { r0 = rf(ctx, userID, recorded) @@ -37,10 +49,44 @@ func (_m *MockNakamaModule) AccountDeleteId(ctx context.Context, userID string, return r0 } +// MockNakamaModule_AccountDeleteId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountDeleteId' +type MockNakamaModule_AccountDeleteId_Call struct { + *mock.Call +} + +// AccountDeleteId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - recorded bool +func (_e *MockNakamaModule_Expecter) AccountDeleteId(ctx interface{}, userID interface{}, recorded interface{}) *MockNakamaModule_AccountDeleteId_Call { + return &MockNakamaModule_AccountDeleteId_Call{Call: _e.mock.On("AccountDeleteId", ctx, userID, recorded)} +} + +func (_c *MockNakamaModule_AccountDeleteId_Call) Run(run func(ctx context.Context, userID string, recorded bool)) *MockNakamaModule_AccountDeleteId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AccountDeleteId_Call) Return(_a0 error) *MockNakamaModule_AccountDeleteId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_AccountDeleteId_Call) RunAndReturn(run func(context.Context, string, bool) error) *MockNakamaModule_AccountDeleteId_Call { + _c.Call.Return(run) + return _c +} + // AccountExportId provides a mock function with given fields: ctx, userID func (_m *MockNakamaModule) AccountExportId(ctx context.Context, userID string) (string, error) { ret := _m.Called(ctx, userID) + if len(ret) == 0 { + panic("no return value specified for AccountExportId") + } + var r0 string var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok { @@ -61,10 +107,43 @@ func (_m *MockNakamaModule) AccountExportId(ctx context.Context, userID string) return r0, r1 } +// MockNakamaModule_AccountExportId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountExportId' +type MockNakamaModule_AccountExportId_Call struct { + *mock.Call +} + +// AccountExportId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +func (_e *MockNakamaModule_Expecter) AccountExportId(ctx interface{}, userID interface{}) *MockNakamaModule_AccountExportId_Call { + return &MockNakamaModule_AccountExportId_Call{Call: _e.mock.On("AccountExportId", ctx, userID)} +} + +func (_c *MockNakamaModule_AccountExportId_Call) Run(run func(ctx context.Context, userID string)) *MockNakamaModule_AccountExportId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_AccountExportId_Call) Return(_a0 string, _a1 error) *MockNakamaModule_AccountExportId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_AccountExportId_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockNakamaModule_AccountExportId_Call { + _c.Call.Return(run) + return _c +} + // AccountGetId provides a mock function with given fields: ctx, userID func (_m *MockNakamaModule) AccountGetId(ctx context.Context, userID string) (*api.Account, error) { ret := _m.Called(ctx, userID) + if len(ret) == 0 { + panic("no return value specified for AccountGetId") + } + var r0 *api.Account var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*api.Account, error)); ok { @@ -87,10 +166,43 @@ func (_m *MockNakamaModule) AccountGetId(ctx context.Context, userID string) (*a return r0, r1 } +// MockNakamaModule_AccountGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountGetId' +type MockNakamaModule_AccountGetId_Call struct { + *mock.Call +} + +// AccountGetId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +func (_e *MockNakamaModule_Expecter) AccountGetId(ctx interface{}, userID interface{}) *MockNakamaModule_AccountGetId_Call { + return &MockNakamaModule_AccountGetId_Call{Call: _e.mock.On("AccountGetId", ctx, userID)} +} + +func (_c *MockNakamaModule_AccountGetId_Call) Run(run func(ctx context.Context, userID string)) *MockNakamaModule_AccountGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_AccountGetId_Call) Return(_a0 *api.Account, _a1 error) *MockNakamaModule_AccountGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_AccountGetId_Call) RunAndReturn(run func(context.Context, string) (*api.Account, error)) *MockNakamaModule_AccountGetId_Call { + _c.Call.Return(run) + return _c +} + // AccountUpdateId provides a mock function with given fields: ctx, userID, username, metadata, displayName, timezone, location, langTag, avatarUrl func (_m *MockNakamaModule) AccountUpdateId(ctx context.Context, userID string, username string, metadata map[string]interface{}, displayName string, timezone string, location string, langTag string, avatarUrl string) error { ret := _m.Called(ctx, userID, username, metadata, displayName, timezone, location, langTag, avatarUrl) + if len(ret) == 0 { + panic("no return value specified for AccountUpdateId") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, map[string]interface{}, string, string, string, string, string) error); ok { r0 = rf(ctx, userID, username, metadata, displayName, timezone, location, langTag, avatarUrl) @@ -101,10 +213,50 @@ func (_m *MockNakamaModule) AccountUpdateId(ctx context.Context, userID string, return r0 } +// MockNakamaModule_AccountUpdateId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountUpdateId' +type MockNakamaModule_AccountUpdateId_Call struct { + *mock.Call +} + +// AccountUpdateId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - metadata map[string]interface{} +// - displayName string +// - timezone string +// - location string +// - langTag string +// - avatarUrl string +func (_e *MockNakamaModule_Expecter) AccountUpdateId(ctx interface{}, userID interface{}, username interface{}, metadata interface{}, displayName interface{}, timezone interface{}, location interface{}, langTag interface{}, avatarUrl interface{}) *MockNakamaModule_AccountUpdateId_Call { + return &MockNakamaModule_AccountUpdateId_Call{Call: _e.mock.On("AccountUpdateId", ctx, userID, username, metadata, displayName, timezone, location, langTag, avatarUrl)} +} + +func (_c *MockNakamaModule_AccountUpdateId_Call) Run(run func(ctx context.Context, userID string, username string, metadata map[string]interface{}, displayName string, timezone string, location string, langTag string, avatarUrl string)) *MockNakamaModule_AccountUpdateId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(map[string]interface{}), args[4].(string), args[5].(string), args[6].(string), args[7].(string), args[8].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_AccountUpdateId_Call) Return(_a0 error) *MockNakamaModule_AccountUpdateId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_AccountUpdateId_Call) RunAndReturn(run func(context.Context, string, string, map[string]interface{}, string, string, string, string, string) error) *MockNakamaModule_AccountUpdateId_Call { + _c.Call.Return(run) + return _c +} + // AccountsGetId provides a mock function with given fields: ctx, userIDs func (_m *MockNakamaModule) AccountsGetId(ctx context.Context, userIDs []string) ([]*api.Account, error) { ret := _m.Called(ctx, userIDs) + if len(ret) == 0 { + panic("no return value specified for AccountsGetId") + } + var r0 []*api.Account var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*api.Account, error)); ok { @@ -127,10 +279,43 @@ func (_m *MockNakamaModule) AccountsGetId(ctx context.Context, userIDs []string) return r0, r1 } +// MockNakamaModule_AccountsGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountsGetId' +type MockNakamaModule_AccountsGetId_Call struct { + *mock.Call +} + +// AccountsGetId is a helper method to define mock.On call +// - ctx context.Context +// - userIDs []string +func (_e *MockNakamaModule_Expecter) AccountsGetId(ctx interface{}, userIDs interface{}) *MockNakamaModule_AccountsGetId_Call { + return &MockNakamaModule_AccountsGetId_Call{Call: _e.mock.On("AccountsGetId", ctx, userIDs)} +} + +func (_c *MockNakamaModule_AccountsGetId_Call) Run(run func(ctx context.Context, userIDs []string)) *MockNakamaModule_AccountsGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_AccountsGetId_Call) Return(_a0 []*api.Account, _a1 error) *MockNakamaModule_AccountsGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_AccountsGetId_Call) RunAndReturn(run func(context.Context, []string) ([]*api.Account, error)) *MockNakamaModule_AccountsGetId_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateApple provides a mock function with given fields: ctx, token, username, create func (_m *MockNakamaModule) AuthenticateApple(ctx context.Context, token string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, token, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateApple") + } + var r0 string var r1 string var r2 bool @@ -165,10 +350,45 @@ func (_m *MockNakamaModule) AuthenticateApple(ctx context.Context, token string, return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateApple' +type MockNakamaModule_AuthenticateApple_Call struct { + *mock.Call +} + +// AuthenticateApple is a helper method to define mock.On call +// - ctx context.Context +// - token string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateApple(ctx interface{}, token interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateApple_Call { + return &MockNakamaModule_AuthenticateApple_Call{Call: _e.mock.On("AuthenticateApple", ctx, token, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateApple_Call) Run(run func(ctx context.Context, token string, username string, create bool)) *MockNakamaModule_AuthenticateApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateApple_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateApple_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateApple_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateApple_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateCustom provides a mock function with given fields: ctx, id, username, create func (_m *MockNakamaModule) AuthenticateCustom(ctx context.Context, id string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, id, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateCustom") + } + var r0 string var r1 string var r2 bool @@ -203,10 +423,45 @@ func (_m *MockNakamaModule) AuthenticateCustom(ctx context.Context, id string, u return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateCustom' +type MockNakamaModule_AuthenticateCustom_Call struct { + *mock.Call +} + +// AuthenticateCustom is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateCustom(ctx interface{}, id interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateCustom_Call { + return &MockNakamaModule_AuthenticateCustom_Call{Call: _e.mock.On("AuthenticateCustom", ctx, id, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateCustom_Call) Run(run func(ctx context.Context, id string, username string, create bool)) *MockNakamaModule_AuthenticateCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateCustom_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateCustom_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateCustom_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateCustom_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateDevice provides a mock function with given fields: ctx, id, username, create func (_m *MockNakamaModule) AuthenticateDevice(ctx context.Context, id string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, id, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateDevice") + } + var r0 string var r1 string var r2 bool @@ -241,10 +496,45 @@ func (_m *MockNakamaModule) AuthenticateDevice(ctx context.Context, id string, u return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateDevice' +type MockNakamaModule_AuthenticateDevice_Call struct { + *mock.Call +} + +// AuthenticateDevice is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateDevice(ctx interface{}, id interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateDevice_Call { + return &MockNakamaModule_AuthenticateDevice_Call{Call: _e.mock.On("AuthenticateDevice", ctx, id, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateDevice_Call) Run(run func(ctx context.Context, id string, username string, create bool)) *MockNakamaModule_AuthenticateDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateDevice_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateDevice_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateDevice_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateDevice_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateEmail provides a mock function with given fields: ctx, email, password, username, create func (_m *MockNakamaModule) AuthenticateEmail(ctx context.Context, email string, password string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, email, password, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateEmail") + } + var r0 string var r1 string var r2 bool @@ -279,10 +569,46 @@ func (_m *MockNakamaModule) AuthenticateEmail(ctx context.Context, email string, return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateEmail' +type MockNakamaModule_AuthenticateEmail_Call struct { + *mock.Call +} + +// AuthenticateEmail is a helper method to define mock.On call +// - ctx context.Context +// - email string +// - password string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateEmail(ctx interface{}, email interface{}, password interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateEmail_Call { + return &MockNakamaModule_AuthenticateEmail_Call{Call: _e.mock.On("AuthenticateEmail", ctx, email, password, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateEmail_Call) Run(run func(ctx context.Context, email string, password string, username string, create bool)) *MockNakamaModule_AuthenticateEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateEmail_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateEmail_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateEmail_Call) RunAndReturn(run func(context.Context, string, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateEmail_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateFacebook provides a mock function with given fields: ctx, token, importFriends, username, create func (_m *MockNakamaModule) AuthenticateFacebook(ctx context.Context, token string, importFriends bool, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, token, importFriends, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateFacebook") + } + var r0 string var r1 string var r2 bool @@ -317,10 +643,46 @@ func (_m *MockNakamaModule) AuthenticateFacebook(ctx context.Context, token stri return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateFacebook' +type MockNakamaModule_AuthenticateFacebook_Call struct { + *mock.Call +} + +// AuthenticateFacebook is a helper method to define mock.On call +// - ctx context.Context +// - token string +// - importFriends bool +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateFacebook(ctx interface{}, token interface{}, importFriends interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateFacebook_Call { + return &MockNakamaModule_AuthenticateFacebook_Call{Call: _e.mock.On("AuthenticateFacebook", ctx, token, importFriends, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateFacebook_Call) Run(run func(ctx context.Context, token string, importFriends bool, username string, create bool)) *MockNakamaModule_AuthenticateFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(bool), args[3].(string), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateFacebook_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateFacebook_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateFacebook_Call) RunAndReturn(run func(context.Context, string, bool, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateFacebook_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateFacebookInstantGame provides a mock function with given fields: ctx, signedPlayerInfo, username, create func (_m *MockNakamaModule) AuthenticateFacebookInstantGame(ctx context.Context, signedPlayerInfo string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, signedPlayerInfo, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateFacebookInstantGame") + } + var r0 string var r1 string var r2 bool @@ -355,10 +717,45 @@ func (_m *MockNakamaModule) AuthenticateFacebookInstantGame(ctx context.Context, return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateFacebookInstantGame' +type MockNakamaModule_AuthenticateFacebookInstantGame_Call struct { + *mock.Call +} + +// AuthenticateFacebookInstantGame is a helper method to define mock.On call +// - ctx context.Context +// - signedPlayerInfo string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateFacebookInstantGame(ctx interface{}, signedPlayerInfo interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateFacebookInstantGame_Call { + return &MockNakamaModule_AuthenticateFacebookInstantGame_Call{Call: _e.mock.On("AuthenticateFacebookInstantGame", ctx, signedPlayerInfo, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateFacebookInstantGame_Call) Run(run func(ctx context.Context, signedPlayerInfo string, username string, create bool)) *MockNakamaModule_AuthenticateFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateFacebookInstantGame_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateFacebookInstantGame_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateFacebookInstantGame_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateGameCenter provides a mock function with given fields: ctx, playerID, bundleID, timestamp, salt, signature, publicKeyUrl, username, create func (_m *MockNakamaModule) AuthenticateGameCenter(ctx context.Context, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, playerID, bundleID, timestamp, salt, signature, publicKeyUrl, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateGameCenter") + } + var r0 string var r1 string var r2 bool @@ -393,10 +790,50 @@ func (_m *MockNakamaModule) AuthenticateGameCenter(ctx context.Context, playerID return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateGameCenter' +type MockNakamaModule_AuthenticateGameCenter_Call struct { + *mock.Call +} + +// AuthenticateGameCenter is a helper method to define mock.On call +// - ctx context.Context +// - playerID string +// - bundleID string +// - timestamp int64 +// - salt string +// - signature string +// - publicKeyUrl string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateGameCenter(ctx interface{}, playerID interface{}, bundleID interface{}, timestamp interface{}, salt interface{}, signature interface{}, publicKeyUrl interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateGameCenter_Call { + return &MockNakamaModule_AuthenticateGameCenter_Call{Call: _e.mock.On("AuthenticateGameCenter", ctx, playerID, bundleID, timestamp, salt, signature, publicKeyUrl, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateGameCenter_Call) Run(run func(ctx context.Context, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string, username string, create bool)) *MockNakamaModule_AuthenticateGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), args[4].(string), args[5].(string), args[6].(string), args[7].(string), args[8].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateGameCenter_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateGameCenter_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateGameCenter_Call) RunAndReturn(run func(context.Context, string, string, int64, string, string, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateGameCenter_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateGoogle provides a mock function with given fields: ctx, token, username, create func (_m *MockNakamaModule) AuthenticateGoogle(ctx context.Context, token string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, token, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateGoogle") + } + var r0 string var r1 string var r2 bool @@ -431,10 +868,45 @@ func (_m *MockNakamaModule) AuthenticateGoogle(ctx context.Context, token string return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateGoogle' +type MockNakamaModule_AuthenticateGoogle_Call struct { + *mock.Call +} + +// AuthenticateGoogle is a helper method to define mock.On call +// - ctx context.Context +// - token string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateGoogle(ctx interface{}, token interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateGoogle_Call { + return &MockNakamaModule_AuthenticateGoogle_Call{Call: _e.mock.On("AuthenticateGoogle", ctx, token, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateGoogle_Call) Run(run func(ctx context.Context, token string, username string, create bool)) *MockNakamaModule_AuthenticateGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateGoogle_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateGoogle_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateGoogle_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateGoogle_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateSteam provides a mock function with given fields: ctx, token, username, create func (_m *MockNakamaModule) AuthenticateSteam(ctx context.Context, token string, username string, create bool) (string, string, bool, error) { ret := _m.Called(ctx, token, username, create) + if len(ret) == 0 { + panic("no return value specified for AuthenticateSteam") + } + var r0 string var r1 string var r2 bool @@ -469,10 +941,45 @@ func (_m *MockNakamaModule) AuthenticateSteam(ctx context.Context, token string, return r0, r1, r2, r3 } +// MockNakamaModule_AuthenticateSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateSteam' +type MockNakamaModule_AuthenticateSteam_Call struct { + *mock.Call +} + +// AuthenticateSteam is a helper method to define mock.On call +// - ctx context.Context +// - token string +// - username string +// - create bool +func (_e *MockNakamaModule_Expecter) AuthenticateSteam(ctx interface{}, token interface{}, username interface{}, create interface{}) *MockNakamaModule_AuthenticateSteam_Call { + return &MockNakamaModule_AuthenticateSteam_Call{Call: _e.mock.On("AuthenticateSteam", ctx, token, username, create)} +} + +func (_c *MockNakamaModule_AuthenticateSteam_Call) Run(run func(ctx context.Context, token string, username string, create bool)) *MockNakamaModule_AuthenticateSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateSteam_Call) Return(_a0 string, _a1 string, _a2 bool, _a3 error) *MockNakamaModule_AuthenticateSteam_Call { + _c.Call.Return(_a0, _a1, _a2, _a3) + return _c +} + +func (_c *MockNakamaModule_AuthenticateSteam_Call) RunAndReturn(run func(context.Context, string, string, bool) (string, string, bool, error)) *MockNakamaModule_AuthenticateSteam_Call { + _c.Call.Return(run) + return _c +} + // AuthenticateTokenGenerate provides a mock function with given fields: userID, username, exp, vars func (_m *MockNakamaModule) AuthenticateTokenGenerate(userID string, username string, exp int64, vars map[string]string) (string, int64, error) { ret := _m.Called(userID, username, exp, vars) + if len(ret) == 0 { + panic("no return value specified for AuthenticateTokenGenerate") + } + var r0 string var r1 int64 var r2 error @@ -500,10 +1007,45 @@ func (_m *MockNakamaModule) AuthenticateTokenGenerate(userID string, username st return r0, r1, r2 } +// MockNakamaModule_AuthenticateTokenGenerate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateTokenGenerate' +type MockNakamaModule_AuthenticateTokenGenerate_Call struct { + *mock.Call +} + +// AuthenticateTokenGenerate is a helper method to define mock.On call +// - userID string +// - username string +// - exp int64 +// - vars map[string]string +func (_e *MockNakamaModule_Expecter) AuthenticateTokenGenerate(userID interface{}, username interface{}, exp interface{}, vars interface{}) *MockNakamaModule_AuthenticateTokenGenerate_Call { + return &MockNakamaModule_AuthenticateTokenGenerate_Call{Call: _e.mock.On("AuthenticateTokenGenerate", userID, username, exp, vars)} +} + +func (_c *MockNakamaModule_AuthenticateTokenGenerate_Call) Run(run func(userID string, username string, exp int64, vars map[string]string)) *MockNakamaModule_AuthenticateTokenGenerate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(int64), args[3].(map[string]string)) + }) + return _c +} + +func (_c *MockNakamaModule_AuthenticateTokenGenerate_Call) Return(_a0 string, _a1 int64, _a2 error) *MockNakamaModule_AuthenticateTokenGenerate_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_AuthenticateTokenGenerate_Call) RunAndReturn(run func(string, string, int64, map[string]string) (string, int64, error)) *MockNakamaModule_AuthenticateTokenGenerate_Call { + _c.Call.Return(run) + return _c +} + // ChannelIdBuild provides a mock function with given fields: ctx, sender, target, chanType func (_m *MockNakamaModule) ChannelIdBuild(ctx context.Context, sender string, target string, chanType runtime.ChannelType) (string, error) { ret := _m.Called(ctx, sender, target, chanType) + if len(ret) == 0 { + panic("no return value specified for ChannelIdBuild") + } + var r0 string var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, runtime.ChannelType) (string, error)); ok { @@ -524,10 +1066,45 @@ func (_m *MockNakamaModule) ChannelIdBuild(ctx context.Context, sender string, t return r0, r1 } +// MockNakamaModule_ChannelIdBuild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelIdBuild' +type MockNakamaModule_ChannelIdBuild_Call struct { + *mock.Call +} + +// ChannelIdBuild is a helper method to define mock.On call +// - ctx context.Context +// - sender string +// - target string +// - chanType runtime.ChannelType +func (_e *MockNakamaModule_Expecter) ChannelIdBuild(ctx interface{}, sender interface{}, target interface{}, chanType interface{}) *MockNakamaModule_ChannelIdBuild_Call { + return &MockNakamaModule_ChannelIdBuild_Call{Call: _e.mock.On("ChannelIdBuild", ctx, sender, target, chanType)} +} + +func (_c *MockNakamaModule_ChannelIdBuild_Call) Run(run func(ctx context.Context, sender string, target string, chanType runtime.ChannelType)) *MockNakamaModule_ChannelIdBuild_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(runtime.ChannelType)) + }) + return _c +} + +func (_c *MockNakamaModule_ChannelIdBuild_Call) Return(_a0 string, _a1 error) *MockNakamaModule_ChannelIdBuild_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_ChannelIdBuild_Call) RunAndReturn(run func(context.Context, string, string, runtime.ChannelType) (string, error)) *MockNakamaModule_ChannelIdBuild_Call { + _c.Call.Return(run) + return _c +} + // ChannelMessageRemove provides a mock function with given fields: ctx, channelId, messageId, senderId, senderUsername, persist func (_m *MockNakamaModule) ChannelMessageRemove(ctx context.Context, channelId string, messageId string, senderId string, senderUsername string, persist bool) (*rtapi.ChannelMessageAck, error) { ret := _m.Called(ctx, channelId, messageId, senderId, senderUsername, persist) + if len(ret) == 0 { + panic("no return value specified for ChannelMessageRemove") + } + var r0 *rtapi.ChannelMessageAck var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, bool) (*rtapi.ChannelMessageAck, error)); ok { @@ -550,10 +1127,47 @@ func (_m *MockNakamaModule) ChannelMessageRemove(ctx context.Context, channelId return r0, r1 } +// MockNakamaModule_ChannelMessageRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMessageRemove' +type MockNakamaModule_ChannelMessageRemove_Call struct { + *mock.Call +} + +// ChannelMessageRemove is a helper method to define mock.On call +// - ctx context.Context +// - channelId string +// - messageId string +// - senderId string +// - senderUsername string +// - persist bool +func (_e *MockNakamaModule_Expecter) ChannelMessageRemove(ctx interface{}, channelId interface{}, messageId interface{}, senderId interface{}, senderUsername interface{}, persist interface{}) *MockNakamaModule_ChannelMessageRemove_Call { + return &MockNakamaModule_ChannelMessageRemove_Call{Call: _e.mock.On("ChannelMessageRemove", ctx, channelId, messageId, senderId, senderUsername, persist)} +} + +func (_c *MockNakamaModule_ChannelMessageRemove_Call) Run(run func(ctx context.Context, channelId string, messageId string, senderId string, senderUsername string, persist bool)) *MockNakamaModule_ChannelMessageRemove_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageRemove_Call) Return(_a0 *rtapi.ChannelMessageAck, _a1 error) *MockNakamaModule_ChannelMessageRemove_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageRemove_Call) RunAndReturn(run func(context.Context, string, string, string, string, bool) (*rtapi.ChannelMessageAck, error)) *MockNakamaModule_ChannelMessageRemove_Call { + _c.Call.Return(run) + return _c +} + // ChannelMessageSend provides a mock function with given fields: ctx, channelID, content, senderId, senderUsername, persist func (_m *MockNakamaModule) ChannelMessageSend(ctx context.Context, channelID string, content map[string]interface{}, senderId string, senderUsername string, persist bool) (*rtapi.ChannelMessageAck, error) { ret := _m.Called(ctx, channelID, content, senderId, senderUsername, persist) + if len(ret) == 0 { + panic("no return value specified for ChannelMessageSend") + } + var r0 *rtapi.ChannelMessageAck var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, map[string]interface{}, string, string, bool) (*rtapi.ChannelMessageAck, error)); ok { @@ -576,10 +1190,47 @@ func (_m *MockNakamaModule) ChannelMessageSend(ctx context.Context, channelID st return r0, r1 } +// MockNakamaModule_ChannelMessageSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMessageSend' +type MockNakamaModule_ChannelMessageSend_Call struct { + *mock.Call +} + +// ChannelMessageSend is a helper method to define mock.On call +// - ctx context.Context +// - channelID string +// - content map[string]interface{} +// - senderId string +// - senderUsername string +// - persist bool +func (_e *MockNakamaModule_Expecter) ChannelMessageSend(ctx interface{}, channelID interface{}, content interface{}, senderId interface{}, senderUsername interface{}, persist interface{}) *MockNakamaModule_ChannelMessageSend_Call { + return &MockNakamaModule_ChannelMessageSend_Call{Call: _e.mock.On("ChannelMessageSend", ctx, channelID, content, senderId, senderUsername, persist)} +} + +func (_c *MockNakamaModule_ChannelMessageSend_Call) Run(run func(ctx context.Context, channelID string, content map[string]interface{}, senderId string, senderUsername string, persist bool)) *MockNakamaModule_ChannelMessageSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{}), args[3].(string), args[4].(string), args[5].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageSend_Call) Return(_a0 *rtapi.ChannelMessageAck, _a1 error) *MockNakamaModule_ChannelMessageSend_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageSend_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}, string, string, bool) (*rtapi.ChannelMessageAck, error)) *MockNakamaModule_ChannelMessageSend_Call { + _c.Call.Return(run) + return _c +} + // ChannelMessageUpdate provides a mock function with given fields: ctx, channelID, messageID, content, senderId, senderUsername, persist func (_m *MockNakamaModule) ChannelMessageUpdate(ctx context.Context, channelID string, messageID string, content map[string]interface{}, senderId string, senderUsername string, persist bool) (*rtapi.ChannelMessageAck, error) { ret := _m.Called(ctx, channelID, messageID, content, senderId, senderUsername, persist) + if len(ret) == 0 { + panic("no return value specified for ChannelMessageUpdate") + } + var r0 *rtapi.ChannelMessageAck var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, map[string]interface{}, string, string, bool) (*rtapi.ChannelMessageAck, error)); ok { @@ -602,10 +1253,48 @@ func (_m *MockNakamaModule) ChannelMessageUpdate(ctx context.Context, channelID return r0, r1 } +// MockNakamaModule_ChannelMessageUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMessageUpdate' +type MockNakamaModule_ChannelMessageUpdate_Call struct { + *mock.Call +} + +// ChannelMessageUpdate is a helper method to define mock.On call +// - ctx context.Context +// - channelID string +// - messageID string +// - content map[string]interface{} +// - senderId string +// - senderUsername string +// - persist bool +func (_e *MockNakamaModule_Expecter) ChannelMessageUpdate(ctx interface{}, channelID interface{}, messageID interface{}, content interface{}, senderId interface{}, senderUsername interface{}, persist interface{}) *MockNakamaModule_ChannelMessageUpdate_Call { + return &MockNakamaModule_ChannelMessageUpdate_Call{Call: _e.mock.On("ChannelMessageUpdate", ctx, channelID, messageID, content, senderId, senderUsername, persist)} +} + +func (_c *MockNakamaModule_ChannelMessageUpdate_Call) Run(run func(ctx context.Context, channelID string, messageID string, content map[string]interface{}, senderId string, senderUsername string, persist bool)) *MockNakamaModule_ChannelMessageUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(map[string]interface{}), args[4].(string), args[5].(string), args[6].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageUpdate_Call) Return(_a0 *rtapi.ChannelMessageAck, _a1 error) *MockNakamaModule_ChannelMessageUpdate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_ChannelMessageUpdate_Call) RunAndReturn(run func(context.Context, string, string, map[string]interface{}, string, string, bool) (*rtapi.ChannelMessageAck, error)) *MockNakamaModule_ChannelMessageUpdate_Call { + _c.Call.Return(run) + return _c +} + // ChannelMessagesList provides a mock function with given fields: ctx, channelId, limit, forward, cursor func (_m *MockNakamaModule) ChannelMessagesList(ctx context.Context, channelId string, limit int, forward bool, cursor string) ([]*api.ChannelMessage, string, string, error) { ret := _m.Called(ctx, channelId, limit, forward, cursor) + if len(ret) == 0 { + panic("no return value specified for ChannelMessagesList") + } + var r0 []*api.ChannelMessage var r1 string var r2 string @@ -642,10 +1331,46 @@ func (_m *MockNakamaModule) ChannelMessagesList(ctx context.Context, channelId s return r0, r1, r2, r3 } +// MockNakamaModule_ChannelMessagesList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMessagesList' +type MockNakamaModule_ChannelMessagesList_Call struct { + *mock.Call +} + +// ChannelMessagesList is a helper method to define mock.On call +// - ctx context.Context +// - channelId string +// - limit int +// - forward bool +// - cursor string +func (_e *MockNakamaModule_Expecter) ChannelMessagesList(ctx interface{}, channelId interface{}, limit interface{}, forward interface{}, cursor interface{}) *MockNakamaModule_ChannelMessagesList_Call { + return &MockNakamaModule_ChannelMessagesList_Call{Call: _e.mock.On("ChannelMessagesList", ctx, channelId, limit, forward, cursor)} +} + +func (_c *MockNakamaModule_ChannelMessagesList_Call) Run(run func(ctx context.Context, channelId string, limit int, forward bool, cursor string)) *MockNakamaModule_ChannelMessagesList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(bool), args[4].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_ChannelMessagesList_Call) Return(messages []*api.ChannelMessage, nextCursor string, prevCursor string, err error) *MockNakamaModule_ChannelMessagesList_Call { + _c.Call.Return(messages, nextCursor, prevCursor, err) + return _c +} + +func (_c *MockNakamaModule_ChannelMessagesList_Call) RunAndReturn(run func(context.Context, string, int, bool, string) ([]*api.ChannelMessage, string, string, error)) *MockNakamaModule_ChannelMessagesList_Call { + _c.Call.Return(run) + return _c +} + // CronNext provides a mock function with given fields: expression, timestamp func (_m *MockNakamaModule) CronNext(expression string, timestamp int64) (int64, error) { ret := _m.Called(expression, timestamp) + if len(ret) == 0 { + panic("no return value specified for CronNext") + } + var r0 int64 var r1 error if rf, ok := ret.Get(0).(func(string, int64) (int64, error)); ok { @@ -666,10 +1391,43 @@ func (_m *MockNakamaModule) CronNext(expression string, timestamp int64) (int64, return r0, r1 } +// MockNakamaModule_CronNext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CronNext' +type MockNakamaModule_CronNext_Call struct { + *mock.Call +} + +// CronNext is a helper method to define mock.On call +// - expression string +// - timestamp int64 +func (_e *MockNakamaModule_Expecter) CronNext(expression interface{}, timestamp interface{}) *MockNakamaModule_CronNext_Call { + return &MockNakamaModule_CronNext_Call{Call: _e.mock.On("CronNext", expression, timestamp)} +} + +func (_c *MockNakamaModule_CronNext_Call) Run(run func(expression string, timestamp int64)) *MockNakamaModule_CronNext_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_CronNext_Call) Return(_a0 int64, _a1 error) *MockNakamaModule_CronNext_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_CronNext_Call) RunAndReturn(run func(string, int64) (int64, error)) *MockNakamaModule_CronNext_Call { + _c.Call.Return(run) + return _c +} + // CronPrev provides a mock function with given fields: expression, timestamp func (_m *MockNakamaModule) CronPrev(expression string, timestamp int64) (int64, error) { ret := _m.Called(expression, timestamp) + if len(ret) == 0 { + panic("no return value specified for CronPrev") + } + var r0 int64 var r1 error if rf, ok := ret.Get(0).(func(string, int64) (int64, error)); ok { @@ -690,10 +1448,43 @@ func (_m *MockNakamaModule) CronPrev(expression string, timestamp int64) (int64, return r0, r1 } +// MockNakamaModule_CronPrev_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CronPrev' +type MockNakamaModule_CronPrev_Call struct { + *mock.Call +} + +// CronPrev is a helper method to define mock.On call +// - expression string +// - timestamp int64 +func (_e *MockNakamaModule_Expecter) CronPrev(expression interface{}, timestamp interface{}) *MockNakamaModule_CronPrev_Call { + return &MockNakamaModule_CronPrev_Call{Call: _e.mock.On("CronPrev", expression, timestamp)} +} + +func (_c *MockNakamaModule_CronPrev_Call) Run(run func(expression string, timestamp int64)) *MockNakamaModule_CronPrev_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_CronPrev_Call) Return(_a0 int64, _a1 error) *MockNakamaModule_CronPrev_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_CronPrev_Call) RunAndReturn(run func(string, int64) (int64, error)) *MockNakamaModule_CronPrev_Call { + _c.Call.Return(run) + return _c +} + // Event provides a mock function with given fields: ctx, evt func (_m *MockNakamaModule) Event(ctx context.Context, evt *api.Event) error { ret := _m.Called(ctx, evt) + if len(ret) == 0 { + panic("no return value specified for Event") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, *api.Event) error); ok { r0 = rf(ctx, evt) @@ -704,10 +1495,43 @@ func (_m *MockNakamaModule) Event(ctx context.Context, evt *api.Event) error { return r0 } +// MockNakamaModule_Event_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Event' +type MockNakamaModule_Event_Call struct { + *mock.Call +} + +// Event is a helper method to define mock.On call +// - ctx context.Context +// - evt *api.Event +func (_e *MockNakamaModule_Expecter) Event(ctx interface{}, evt interface{}) *MockNakamaModule_Event_Call { + return &MockNakamaModule_Event_Call{Call: _e.mock.On("Event", ctx, evt)} +} + +func (_c *MockNakamaModule_Event_Call) Run(run func(ctx context.Context, evt *api.Event)) *MockNakamaModule_Event_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*api.Event)) + }) + return _c +} + +func (_c *MockNakamaModule_Event_Call) Return(_a0 error) *MockNakamaModule_Event_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_Event_Call) RunAndReturn(run func(context.Context, *api.Event) error) *MockNakamaModule_Event_Call { + _c.Call.Return(run) + return _c +} + // FriendsAdd provides a mock function with given fields: ctx, userID, username, ids, usernames func (_m *MockNakamaModule) FriendsAdd(ctx context.Context, userID string, username string, ids []string, usernames []string) error { ret := _m.Called(ctx, userID, username, ids, usernames) + if len(ret) == 0 { + panic("no return value specified for FriendsAdd") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string, []string) error); ok { r0 = rf(ctx, userID, username, ids, usernames) @@ -718,10 +1542,46 @@ func (_m *MockNakamaModule) FriendsAdd(ctx context.Context, userID string, usern return r0 } +// MockNakamaModule_FriendsAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FriendsAdd' +type MockNakamaModule_FriendsAdd_Call struct { + *mock.Call +} + +// FriendsAdd is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - ids []string +// - usernames []string +func (_e *MockNakamaModule_Expecter) FriendsAdd(ctx interface{}, userID interface{}, username interface{}, ids interface{}, usernames interface{}) *MockNakamaModule_FriendsAdd_Call { + return &MockNakamaModule_FriendsAdd_Call{Call: _e.mock.On("FriendsAdd", ctx, userID, username, ids, usernames)} +} + +func (_c *MockNakamaModule_FriendsAdd_Call) Run(run func(ctx context.Context, userID string, username string, ids []string, usernames []string)) *MockNakamaModule_FriendsAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string), args[4].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_FriendsAdd_Call) Return(_a0 error) *MockNakamaModule_FriendsAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_FriendsAdd_Call) RunAndReturn(run func(context.Context, string, string, []string, []string) error) *MockNakamaModule_FriendsAdd_Call { + _c.Call.Return(run) + return _c +} + // FriendsBlock provides a mock function with given fields: ctx, userID, username, ids, usernames func (_m *MockNakamaModule) FriendsBlock(ctx context.Context, userID string, username string, ids []string, usernames []string) error { ret := _m.Called(ctx, userID, username, ids, usernames) + if len(ret) == 0 { + panic("no return value specified for FriendsBlock") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string, []string) error); ok { r0 = rf(ctx, userID, username, ids, usernames) @@ -732,10 +1592,46 @@ func (_m *MockNakamaModule) FriendsBlock(ctx context.Context, userID string, use return r0 } +// MockNakamaModule_FriendsBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FriendsBlock' +type MockNakamaModule_FriendsBlock_Call struct { + *mock.Call +} + +// FriendsBlock is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - ids []string +// - usernames []string +func (_e *MockNakamaModule_Expecter) FriendsBlock(ctx interface{}, userID interface{}, username interface{}, ids interface{}, usernames interface{}) *MockNakamaModule_FriendsBlock_Call { + return &MockNakamaModule_FriendsBlock_Call{Call: _e.mock.On("FriendsBlock", ctx, userID, username, ids, usernames)} +} + +func (_c *MockNakamaModule_FriendsBlock_Call) Run(run func(ctx context.Context, userID string, username string, ids []string, usernames []string)) *MockNakamaModule_FriendsBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string), args[4].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_FriendsBlock_Call) Return(_a0 error) *MockNakamaModule_FriendsBlock_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_FriendsBlock_Call) RunAndReturn(run func(context.Context, string, string, []string, []string) error) *MockNakamaModule_FriendsBlock_Call { + _c.Call.Return(run) + return _c +} + // FriendsDelete provides a mock function with given fields: ctx, userID, username, ids, usernames func (_m *MockNakamaModule) FriendsDelete(ctx context.Context, userID string, username string, ids []string, usernames []string) error { ret := _m.Called(ctx, userID, username, ids, usernames) + if len(ret) == 0 { + panic("no return value specified for FriendsDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string, []string) error); ok { r0 = rf(ctx, userID, username, ids, usernames) @@ -746,10 +1642,46 @@ func (_m *MockNakamaModule) FriendsDelete(ctx context.Context, userID string, us return r0 } +// MockNakamaModule_FriendsDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FriendsDelete' +type MockNakamaModule_FriendsDelete_Call struct { + *mock.Call +} + +// FriendsDelete is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - ids []string +// - usernames []string +func (_e *MockNakamaModule_Expecter) FriendsDelete(ctx interface{}, userID interface{}, username interface{}, ids interface{}, usernames interface{}) *MockNakamaModule_FriendsDelete_Call { + return &MockNakamaModule_FriendsDelete_Call{Call: _e.mock.On("FriendsDelete", ctx, userID, username, ids, usernames)} +} + +func (_c *MockNakamaModule_FriendsDelete_Call) Run(run func(ctx context.Context, userID string, username string, ids []string, usernames []string)) *MockNakamaModule_FriendsDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string), args[4].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_FriendsDelete_Call) Return(_a0 error) *MockNakamaModule_FriendsDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_FriendsDelete_Call) RunAndReturn(run func(context.Context, string, string, []string, []string) error) *MockNakamaModule_FriendsDelete_Call { + _c.Call.Return(run) + return _c +} + // FriendsList provides a mock function with given fields: ctx, userID, limit, state, cursor func (_m *MockNakamaModule) FriendsList(ctx context.Context, userID string, limit int, state *int, cursor string) ([]*api.Friend, string, error) { ret := _m.Called(ctx, userID, limit, state, cursor) + if len(ret) == 0 { + panic("no return value specified for FriendsList") + } + var r0 []*api.Friend var r1 string var r2 error @@ -779,10 +1711,46 @@ func (_m *MockNakamaModule) FriendsList(ctx context.Context, userID string, limi return r0, r1, r2 } +// MockNakamaModule_FriendsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FriendsList' +type MockNakamaModule_FriendsList_Call struct { + *mock.Call +} + +// FriendsList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - state *int +// - cursor string +func (_e *MockNakamaModule_Expecter) FriendsList(ctx interface{}, userID interface{}, limit interface{}, state interface{}, cursor interface{}) *MockNakamaModule_FriendsList_Call { + return &MockNakamaModule_FriendsList_Call{Call: _e.mock.On("FriendsList", ctx, userID, limit, state, cursor)} +} + +func (_c *MockNakamaModule_FriendsList_Call) Run(run func(ctx context.Context, userID string, limit int, state *int, cursor string)) *MockNakamaModule_FriendsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(*int), args[4].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_FriendsList_Call) Return(_a0 []*api.Friend, _a1 string, _a2 error) *MockNakamaModule_FriendsList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_FriendsList_Call) RunAndReturn(run func(context.Context, string, int, *int, string) ([]*api.Friend, string, error)) *MockNakamaModule_FriendsList_Call { + _c.Call.Return(run) + return _c +} + // FriendsOfFriendsList provides a mock function with given fields: ctx, userID, limit, cursor func (_m *MockNakamaModule) FriendsOfFriendsList(ctx context.Context, userID string, limit int, cursor string) ([]*api.FriendsOfFriendsList_FriendOfFriend, string, error) { ret := _m.Called(ctx, userID, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for FriendsOfFriendsList") + } + var r0 []*api.FriendsOfFriendsList_FriendOfFriend var r1 string var r2 error @@ -812,10 +1780,45 @@ func (_m *MockNakamaModule) FriendsOfFriendsList(ctx context.Context, userID str return r0, r1, r2 } -// GetFleetManager provides a mock function with given fields: +// MockNakamaModule_FriendsOfFriendsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FriendsOfFriendsList' +type MockNakamaModule_FriendsOfFriendsList_Call struct { + *mock.Call +} + +// FriendsOfFriendsList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) FriendsOfFriendsList(ctx interface{}, userID interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_FriendsOfFriendsList_Call { + return &MockNakamaModule_FriendsOfFriendsList_Call{Call: _e.mock.On("FriendsOfFriendsList", ctx, userID, limit, cursor)} +} + +func (_c *MockNakamaModule_FriendsOfFriendsList_Call) Run(run func(ctx context.Context, userID string, limit int, cursor string)) *MockNakamaModule_FriendsOfFriendsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_FriendsOfFriendsList_Call) Return(_a0 []*api.FriendsOfFriendsList_FriendOfFriend, _a1 string, _a2 error) *MockNakamaModule_FriendsOfFriendsList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_FriendsOfFriendsList_Call) RunAndReturn(run func(context.Context, string, int, string) ([]*api.FriendsOfFriendsList_FriendOfFriend, string, error)) *MockNakamaModule_FriendsOfFriendsList_Call { + _c.Call.Return(run) + return _c +} + +// GetFleetManager provides a mock function with no fields func (_m *MockNakamaModule) GetFleetManager() runtime.FleetManager { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetFleetManager") + } + var r0 runtime.FleetManager if rf, ok := ret.Get(0).(func() runtime.FleetManager); ok { r0 = rf() @@ -828,10 +1831,41 @@ func (_m *MockNakamaModule) GetFleetManager() runtime.FleetManager { return r0 } -// GetSatori provides a mock function with given fields: +// MockNakamaModule_GetFleetManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFleetManager' +type MockNakamaModule_GetFleetManager_Call struct { + *mock.Call +} + +// GetFleetManager is a helper method to define mock.On call +func (_e *MockNakamaModule_Expecter) GetFleetManager() *MockNakamaModule_GetFleetManager_Call { + return &MockNakamaModule_GetFleetManager_Call{Call: _e.mock.On("GetFleetManager")} +} + +func (_c *MockNakamaModule_GetFleetManager_Call) Run(run func()) *MockNakamaModule_GetFleetManager_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNakamaModule_GetFleetManager_Call) Return(_a0 runtime.FleetManager) *MockNakamaModule_GetFleetManager_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GetFleetManager_Call) RunAndReturn(run func() runtime.FleetManager) *MockNakamaModule_GetFleetManager_Call { + _c.Call.Return(run) + return _c +} + +// GetSatori provides a mock function with no fields func (_m *MockNakamaModule) GetSatori() runtime.Satori { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetSatori") + } + var r0 runtime.Satori if rf, ok := ret.Get(0).(func() runtime.Satori); ok { r0 = rf() @@ -844,10 +1878,41 @@ func (_m *MockNakamaModule) GetSatori() runtime.Satori { return r0 } +// MockNakamaModule_GetSatori_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSatori' +type MockNakamaModule_GetSatori_Call struct { + *mock.Call +} + +// GetSatori is a helper method to define mock.On call +func (_e *MockNakamaModule_Expecter) GetSatori() *MockNakamaModule_GetSatori_Call { + return &MockNakamaModule_GetSatori_Call{Call: _e.mock.On("GetSatori")} +} + +func (_c *MockNakamaModule_GetSatori_Call) Run(run func()) *MockNakamaModule_GetSatori_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockNakamaModule_GetSatori_Call) Return(_a0 runtime.Satori) *MockNakamaModule_GetSatori_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GetSatori_Call) RunAndReturn(run func() runtime.Satori) *MockNakamaModule_GetSatori_Call { + _c.Call.Return(run) + return _c +} + // GroupCreate provides a mock function with given fields: ctx, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount func (_m *MockNakamaModule) GroupCreate(ctx context.Context, userID string, name string, creatorID string, langTag string, description string, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int) (*api.Group, error) { ret := _m.Called(ctx, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount) + if len(ret) == 0 { + panic("no return value specified for GroupCreate") + } + var r0 *api.Group var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string, bool, map[string]interface{}, int) (*api.Group, error)); ok { @@ -870,10 +1935,51 @@ func (_m *MockNakamaModule) GroupCreate(ctx context.Context, userID string, name return r0, r1 } +// MockNakamaModule_GroupCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupCreate' +type MockNakamaModule_GroupCreate_Call struct { + *mock.Call +} + +// GroupCreate is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - name string +// - creatorID string +// - langTag string +// - description string +// - avatarUrl string +// - open bool +// - metadata map[string]interface{} +// - maxCount int +func (_e *MockNakamaModule_Expecter) GroupCreate(ctx interface{}, userID interface{}, name interface{}, creatorID interface{}, langTag interface{}, description interface{}, avatarUrl interface{}, open interface{}, metadata interface{}, maxCount interface{}) *MockNakamaModule_GroupCreate_Call { + return &MockNakamaModule_GroupCreate_Call{Call: _e.mock.On("GroupCreate", ctx, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount)} +} + +func (_c *MockNakamaModule_GroupCreate_Call) Run(run func(ctx context.Context, userID string, name string, creatorID string, langTag string, description string, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int)) *MockNakamaModule_GroupCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(string), args[7].(bool), args[8].(map[string]interface{}), args[9].(int)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupCreate_Call) Return(_a0 *api.Group, _a1 error) *MockNakamaModule_GroupCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_GroupCreate_Call) RunAndReturn(run func(context.Context, string, string, string, string, string, string, bool, map[string]interface{}, int) (*api.Group, error)) *MockNakamaModule_GroupCreate_Call { + _c.Call.Return(run) + return _c +} + // GroupDelete provides a mock function with given fields: ctx, id func (_m *MockNakamaModule) GroupDelete(ctx context.Context, id string) error { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for GroupDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, id) @@ -884,10 +1990,43 @@ func (_m *MockNakamaModule) GroupDelete(ctx context.Context, id string) error { return r0 } +// MockNakamaModule_GroupDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupDelete' +type MockNakamaModule_GroupDelete_Call struct { + *mock.Call +} + +// GroupDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) GroupDelete(ctx interface{}, id interface{}) *MockNakamaModule_GroupDelete_Call { + return &MockNakamaModule_GroupDelete_Call{Call: _e.mock.On("GroupDelete", ctx, id)} +} + +func (_c *MockNakamaModule_GroupDelete_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_GroupDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupDelete_Call) Return(_a0 error) *MockNakamaModule_GroupDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupDelete_Call) RunAndReturn(run func(context.Context, string) error) *MockNakamaModule_GroupDelete_Call { + _c.Call.Return(run) + return _c +} + // GroupUpdate provides a mock function with given fields: ctx, id, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount func (_m *MockNakamaModule) GroupUpdate(ctx context.Context, id string, userID string, name string, creatorID string, langTag string, description string, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int) error { ret := _m.Called(ctx, id, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount) + if len(ret) == 0 { + panic("no return value specified for GroupUpdate") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string, string, bool, map[string]interface{}, int) error); ok { r0 = rf(ctx, id, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount) @@ -898,10 +2037,52 @@ func (_m *MockNakamaModule) GroupUpdate(ctx context.Context, id string, userID s return r0 } +// MockNakamaModule_GroupUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUpdate' +type MockNakamaModule_GroupUpdate_Call struct { + *mock.Call +} + +// GroupUpdate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userID string +// - name string +// - creatorID string +// - langTag string +// - description string +// - avatarUrl string +// - open bool +// - metadata map[string]interface{} +// - maxCount int +func (_e *MockNakamaModule_Expecter) GroupUpdate(ctx interface{}, id interface{}, userID interface{}, name interface{}, creatorID interface{}, langTag interface{}, description interface{}, avatarUrl interface{}, open interface{}, metadata interface{}, maxCount interface{}) *MockNakamaModule_GroupUpdate_Call { + return &MockNakamaModule_GroupUpdate_Call{Call: _e.mock.On("GroupUpdate", ctx, id, userID, name, creatorID, langTag, description, avatarUrl, open, metadata, maxCount)} +} + +func (_c *MockNakamaModule_GroupUpdate_Call) Run(run func(ctx context.Context, id string, userID string, name string, creatorID string, langTag string, description string, avatarUrl string, open bool, metadata map[string]interface{}, maxCount int)) *MockNakamaModule_GroupUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(string), args[7].(string), args[8].(bool), args[9].(map[string]interface{}), args[10].(int)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUpdate_Call) Return(_a0 error) *MockNakamaModule_GroupUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUpdate_Call) RunAndReturn(run func(context.Context, string, string, string, string, string, string, string, bool, map[string]interface{}, int) error) *MockNakamaModule_GroupUpdate_Call { + _c.Call.Return(run) + return _c +} + // GroupUserJoin provides a mock function with given fields: ctx, groupID, userID, username func (_m *MockNakamaModule) GroupUserJoin(ctx context.Context, groupID string, userID string, username string) error { ret := _m.Called(ctx, groupID, userID, username) + if len(ret) == 0 { + panic("no return value specified for GroupUserJoin") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { r0 = rf(ctx, groupID, userID, username) @@ -912,10 +2093,45 @@ func (_m *MockNakamaModule) GroupUserJoin(ctx context.Context, groupID string, u return r0 } +// MockNakamaModule_GroupUserJoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUserJoin' +type MockNakamaModule_GroupUserJoin_Call struct { + *mock.Call +} + +// GroupUserJoin is a helper method to define mock.On call +// - ctx context.Context +// - groupID string +// - userID string +// - username string +func (_e *MockNakamaModule_Expecter) GroupUserJoin(ctx interface{}, groupID interface{}, userID interface{}, username interface{}) *MockNakamaModule_GroupUserJoin_Call { + return &MockNakamaModule_GroupUserJoin_Call{Call: _e.mock.On("GroupUserJoin", ctx, groupID, userID, username)} +} + +func (_c *MockNakamaModule_GroupUserJoin_Call) Run(run func(ctx context.Context, groupID string, userID string, username string)) *MockNakamaModule_GroupUserJoin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUserJoin_Call) Return(_a0 error) *MockNakamaModule_GroupUserJoin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUserJoin_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockNakamaModule_GroupUserJoin_Call { + _c.Call.Return(run) + return _c +} + // GroupUserLeave provides a mock function with given fields: ctx, groupID, userID, username func (_m *MockNakamaModule) GroupUserLeave(ctx context.Context, groupID string, userID string, username string) error { ret := _m.Called(ctx, groupID, userID, username) + if len(ret) == 0 { + panic("no return value specified for GroupUserLeave") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { r0 = rf(ctx, groupID, userID, username) @@ -926,10 +2142,45 @@ func (_m *MockNakamaModule) GroupUserLeave(ctx context.Context, groupID string, return r0 } +// MockNakamaModule_GroupUserLeave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUserLeave' +type MockNakamaModule_GroupUserLeave_Call struct { + *mock.Call +} + +// GroupUserLeave is a helper method to define mock.On call +// - ctx context.Context +// - groupID string +// - userID string +// - username string +func (_e *MockNakamaModule_Expecter) GroupUserLeave(ctx interface{}, groupID interface{}, userID interface{}, username interface{}) *MockNakamaModule_GroupUserLeave_Call { + return &MockNakamaModule_GroupUserLeave_Call{Call: _e.mock.On("GroupUserLeave", ctx, groupID, userID, username)} +} + +func (_c *MockNakamaModule_GroupUserLeave_Call) Run(run func(ctx context.Context, groupID string, userID string, username string)) *MockNakamaModule_GroupUserLeave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUserLeave_Call) Return(_a0 error) *MockNakamaModule_GroupUserLeave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUserLeave_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockNakamaModule_GroupUserLeave_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersAdd provides a mock function with given fields: ctx, callerID, groupID, userIDs func (_m *MockNakamaModule) GroupUsersAdd(ctx context.Context, callerID string, groupID string, userIDs []string) error { ret := _m.Called(ctx, callerID, groupID, userIDs) + if len(ret) == 0 { + panic("no return value specified for GroupUsersAdd") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string) error); ok { r0 = rf(ctx, callerID, groupID, userIDs) @@ -940,10 +2191,45 @@ func (_m *MockNakamaModule) GroupUsersAdd(ctx context.Context, callerID string, return r0 } +// MockNakamaModule_GroupUsersAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersAdd' +type MockNakamaModule_GroupUsersAdd_Call struct { + *mock.Call +} + +// GroupUsersAdd is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - groupID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) GroupUsersAdd(ctx interface{}, callerID interface{}, groupID interface{}, userIDs interface{}) *MockNakamaModule_GroupUsersAdd_Call { + return &MockNakamaModule_GroupUsersAdd_Call{Call: _e.mock.On("GroupUsersAdd", ctx, callerID, groupID, userIDs)} +} + +func (_c *MockNakamaModule_GroupUsersAdd_Call) Run(run func(ctx context.Context, callerID string, groupID string, userIDs []string)) *MockNakamaModule_GroupUsersAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersAdd_Call) Return(_a0 error) *MockNakamaModule_GroupUsersAdd_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUsersAdd_Call) RunAndReturn(run func(context.Context, string, string, []string) error) *MockNakamaModule_GroupUsersAdd_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersBan provides a mock function with given fields: ctx, callerID, groupID, userIDs func (_m *MockNakamaModule) GroupUsersBan(ctx context.Context, callerID string, groupID string, userIDs []string) error { ret := _m.Called(ctx, callerID, groupID, userIDs) + if len(ret) == 0 { + panic("no return value specified for GroupUsersBan") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string) error); ok { r0 = rf(ctx, callerID, groupID, userIDs) @@ -954,10 +2240,45 @@ func (_m *MockNakamaModule) GroupUsersBan(ctx context.Context, callerID string, return r0 } +// MockNakamaModule_GroupUsersBan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersBan' +type MockNakamaModule_GroupUsersBan_Call struct { + *mock.Call +} + +// GroupUsersBan is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - groupID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) GroupUsersBan(ctx interface{}, callerID interface{}, groupID interface{}, userIDs interface{}) *MockNakamaModule_GroupUsersBan_Call { + return &MockNakamaModule_GroupUsersBan_Call{Call: _e.mock.On("GroupUsersBan", ctx, callerID, groupID, userIDs)} +} + +func (_c *MockNakamaModule_GroupUsersBan_Call) Run(run func(ctx context.Context, callerID string, groupID string, userIDs []string)) *MockNakamaModule_GroupUsersBan_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersBan_Call) Return(_a0 error) *MockNakamaModule_GroupUsersBan_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUsersBan_Call) RunAndReturn(run func(context.Context, string, string, []string) error) *MockNakamaModule_GroupUsersBan_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersDemote provides a mock function with given fields: ctx, callerID, groupID, userIDs func (_m *MockNakamaModule) GroupUsersDemote(ctx context.Context, callerID string, groupID string, userIDs []string) error { ret := _m.Called(ctx, callerID, groupID, userIDs) + if len(ret) == 0 { + panic("no return value specified for GroupUsersDemote") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string) error); ok { r0 = rf(ctx, callerID, groupID, userIDs) @@ -968,10 +2289,45 @@ func (_m *MockNakamaModule) GroupUsersDemote(ctx context.Context, callerID strin return r0 } +// MockNakamaModule_GroupUsersDemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersDemote' +type MockNakamaModule_GroupUsersDemote_Call struct { + *mock.Call +} + +// GroupUsersDemote is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - groupID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) GroupUsersDemote(ctx interface{}, callerID interface{}, groupID interface{}, userIDs interface{}) *MockNakamaModule_GroupUsersDemote_Call { + return &MockNakamaModule_GroupUsersDemote_Call{Call: _e.mock.On("GroupUsersDemote", ctx, callerID, groupID, userIDs)} +} + +func (_c *MockNakamaModule_GroupUsersDemote_Call) Run(run func(ctx context.Context, callerID string, groupID string, userIDs []string)) *MockNakamaModule_GroupUsersDemote_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersDemote_Call) Return(_a0 error) *MockNakamaModule_GroupUsersDemote_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUsersDemote_Call) RunAndReturn(run func(context.Context, string, string, []string) error) *MockNakamaModule_GroupUsersDemote_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersKick provides a mock function with given fields: ctx, callerID, groupID, userIDs func (_m *MockNakamaModule) GroupUsersKick(ctx context.Context, callerID string, groupID string, userIDs []string) error { ret := _m.Called(ctx, callerID, groupID, userIDs) + if len(ret) == 0 { + panic("no return value specified for GroupUsersKick") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string) error); ok { r0 = rf(ctx, callerID, groupID, userIDs) @@ -982,10 +2338,45 @@ func (_m *MockNakamaModule) GroupUsersKick(ctx context.Context, callerID string, return r0 } +// MockNakamaModule_GroupUsersKick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersKick' +type MockNakamaModule_GroupUsersKick_Call struct { + *mock.Call +} + +// GroupUsersKick is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - groupID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) GroupUsersKick(ctx interface{}, callerID interface{}, groupID interface{}, userIDs interface{}) *MockNakamaModule_GroupUsersKick_Call { + return &MockNakamaModule_GroupUsersKick_Call{Call: _e.mock.On("GroupUsersKick", ctx, callerID, groupID, userIDs)} +} + +func (_c *MockNakamaModule_GroupUsersKick_Call) Run(run func(ctx context.Context, callerID string, groupID string, userIDs []string)) *MockNakamaModule_GroupUsersKick_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersKick_Call) Return(_a0 error) *MockNakamaModule_GroupUsersKick_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUsersKick_Call) RunAndReturn(run func(context.Context, string, string, []string) error) *MockNakamaModule_GroupUsersKick_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersList provides a mock function with given fields: ctx, id, limit, state, cursor func (_m *MockNakamaModule) GroupUsersList(ctx context.Context, id string, limit int, state *int, cursor string) ([]*api.GroupUserList_GroupUser, string, error) { ret := _m.Called(ctx, id, limit, state, cursor) + if len(ret) == 0 { + panic("no return value specified for GroupUsersList") + } + var r0 []*api.GroupUserList_GroupUser var r1 string var r2 error @@ -1015,10 +2406,46 @@ func (_m *MockNakamaModule) GroupUsersList(ctx context.Context, id string, limit return r0, r1, r2 } +// MockNakamaModule_GroupUsersList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersList' +type MockNakamaModule_GroupUsersList_Call struct { + *mock.Call +} + +// GroupUsersList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - limit int +// - state *int +// - cursor string +func (_e *MockNakamaModule_Expecter) GroupUsersList(ctx interface{}, id interface{}, limit interface{}, state interface{}, cursor interface{}) *MockNakamaModule_GroupUsersList_Call { + return &MockNakamaModule_GroupUsersList_Call{Call: _e.mock.On("GroupUsersList", ctx, id, limit, state, cursor)} +} + +func (_c *MockNakamaModule_GroupUsersList_Call) Run(run func(ctx context.Context, id string, limit int, state *int, cursor string)) *MockNakamaModule_GroupUsersList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(*int), args[4].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersList_Call) Return(_a0 []*api.GroupUserList_GroupUser, _a1 string, _a2 error) *MockNakamaModule_GroupUsersList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_GroupUsersList_Call) RunAndReturn(run func(context.Context, string, int, *int, string) ([]*api.GroupUserList_GroupUser, string, error)) *MockNakamaModule_GroupUsersList_Call { + _c.Call.Return(run) + return _c +} + // GroupUsersPromote provides a mock function with given fields: ctx, callerID, groupID, userIDs func (_m *MockNakamaModule) GroupUsersPromote(ctx context.Context, callerID string, groupID string, userIDs []string) error { ret := _m.Called(ctx, callerID, groupID, userIDs) + if len(ret) == 0 { + panic("no return value specified for GroupUsersPromote") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, []string) error); ok { r0 = rf(ctx, callerID, groupID, userIDs) @@ -1029,10 +2456,45 @@ func (_m *MockNakamaModule) GroupUsersPromote(ctx context.Context, callerID stri return r0 } +// MockNakamaModule_GroupUsersPromote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupUsersPromote' +type MockNakamaModule_GroupUsersPromote_Call struct { + *mock.Call +} + +// GroupUsersPromote is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - groupID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) GroupUsersPromote(ctx interface{}, callerID interface{}, groupID interface{}, userIDs interface{}) *MockNakamaModule_GroupUsersPromote_Call { + return &MockNakamaModule_GroupUsersPromote_Call{Call: _e.mock.On("GroupUsersPromote", ctx, callerID, groupID, userIDs)} +} + +func (_c *MockNakamaModule_GroupUsersPromote_Call) Run(run func(ctx context.Context, callerID string, groupID string, userIDs []string)) *MockNakamaModule_GroupUsersPromote_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupUsersPromote_Call) Return(_a0 error) *MockNakamaModule_GroupUsersPromote_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_GroupUsersPromote_Call) RunAndReturn(run func(context.Context, string, string, []string) error) *MockNakamaModule_GroupUsersPromote_Call { + _c.Call.Return(run) + return _c +} + // GroupsGetId provides a mock function with given fields: ctx, groupIDs func (_m *MockNakamaModule) GroupsGetId(ctx context.Context, groupIDs []string) ([]*api.Group, error) { ret := _m.Called(ctx, groupIDs) + if len(ret) == 0 { + panic("no return value specified for GroupsGetId") + } + var r0 []*api.Group var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*api.Group, error)); ok { @@ -1055,10 +2517,43 @@ func (_m *MockNakamaModule) GroupsGetId(ctx context.Context, groupIDs []string) return r0, r1 } +// MockNakamaModule_GroupsGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsGetId' +type MockNakamaModule_GroupsGetId_Call struct { + *mock.Call +} + +// GroupsGetId is a helper method to define mock.On call +// - ctx context.Context +// - groupIDs []string +func (_e *MockNakamaModule_Expecter) GroupsGetId(ctx interface{}, groupIDs interface{}) *MockNakamaModule_GroupsGetId_Call { + return &MockNakamaModule_GroupsGetId_Call{Call: _e.mock.On("GroupsGetId", ctx, groupIDs)} +} + +func (_c *MockNakamaModule_GroupsGetId_Call) Run(run func(ctx context.Context, groupIDs []string)) *MockNakamaModule_GroupsGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupsGetId_Call) Return(_a0 []*api.Group, _a1 error) *MockNakamaModule_GroupsGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_GroupsGetId_Call) RunAndReturn(run func(context.Context, []string) ([]*api.Group, error)) *MockNakamaModule_GroupsGetId_Call { + _c.Call.Return(run) + return _c +} + // GroupsGetRandom provides a mock function with given fields: ctx, count func (_m *MockNakamaModule) GroupsGetRandom(ctx context.Context, count int) ([]*api.Group, error) { ret := _m.Called(ctx, count) + if len(ret) == 0 { + panic("no return value specified for GroupsGetRandom") + } + var r0 []*api.Group var r1 error if rf, ok := ret.Get(0).(func(context.Context, int) ([]*api.Group, error)); ok { @@ -1081,10 +2576,43 @@ func (_m *MockNakamaModule) GroupsGetRandom(ctx context.Context, count int) ([]* return r0, r1 } -// GroupsList provides a mock function with given fields: ctx, name, langTag, members, open, limit, cursor -func (_m *MockNakamaModule) GroupsList(ctx context.Context, name string, langTag string, members *int, open *bool, limit int, cursor string) ([]*api.Group, string, error) { +// MockNakamaModule_GroupsGetRandom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsGetRandom' +type MockNakamaModule_GroupsGetRandom_Call struct { + *mock.Call +} + +// GroupsGetRandom is a helper method to define mock.On call +// - ctx context.Context +// - count int +func (_e *MockNakamaModule_Expecter) GroupsGetRandom(ctx interface{}, count interface{}) *MockNakamaModule_GroupsGetRandom_Call { + return &MockNakamaModule_GroupsGetRandom_Call{Call: _e.mock.On("GroupsGetRandom", ctx, count)} +} + +func (_c *MockNakamaModule_GroupsGetRandom_Call) Run(run func(ctx context.Context, count int)) *MockNakamaModule_GroupsGetRandom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupsGetRandom_Call) Return(_a0 []*api.Group, _a1 error) *MockNakamaModule_GroupsGetRandom_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_GroupsGetRandom_Call) RunAndReturn(run func(context.Context, int) ([]*api.Group, error)) *MockNakamaModule_GroupsGetRandom_Call { + _c.Call.Return(run) + return _c +} + +// GroupsList provides a mock function with given fields: ctx, name, langTag, members, open, limit, cursor +func (_m *MockNakamaModule) GroupsList(ctx context.Context, name string, langTag string, members *int, open *bool, limit int, cursor string) ([]*api.Group, string, error) { ret := _m.Called(ctx, name, langTag, members, open, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for GroupsList") + } + var r0 []*api.Group var r1 string var r2 error @@ -1114,13 +2642,51 @@ func (_m *MockNakamaModule) GroupsList(ctx context.Context, name string, langTag return r0, r1, r2 } -// LeaderboardCreate provides a mock function with given fields: ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata -func (_m *MockNakamaModule) LeaderboardCreate(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}) error { - ret := _m.Called(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata) +// MockNakamaModule_GroupsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsList' +type MockNakamaModule_GroupsList_Call struct { + *mock.Call +} + +// GroupsList is a helper method to define mock.On call +// - ctx context.Context +// - name string +// - langTag string +// - members *int +// - open *bool +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) GroupsList(ctx interface{}, name interface{}, langTag interface{}, members interface{}, open interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_GroupsList_Call { + return &MockNakamaModule_GroupsList_Call{Call: _e.mock.On("GroupsList", ctx, name, langTag, members, open, limit, cursor)} +} + +func (_c *MockNakamaModule_GroupsList_Call) Run(run func(ctx context.Context, name string, langTag string, members *int, open *bool, limit int, cursor string)) *MockNakamaModule_GroupsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*int), args[4].(*bool), args[5].(int), args[6].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_GroupsList_Call) Return(_a0 []*api.Group, _a1 string, _a2 error) *MockNakamaModule_GroupsList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_GroupsList_Call) RunAndReturn(run func(context.Context, string, string, *int, *bool, int, string) ([]*api.Group, string, error)) *MockNakamaModule_GroupsList_Call { + _c.Call.Return(run) + return _c +} + +// LeaderboardCreate provides a mock function with given fields: ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, enableRanks +func (_m *MockNakamaModule) LeaderboardCreate(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}, enableRanks bool) error { + ret := _m.Called(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, enableRanks) + + if len(ret) == 0 { + panic("no return value specified for LeaderboardCreate") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, bool, string, string, string, map[string]interface{}) error); ok { - r0 = rf(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata) + if rf, ok := ret.Get(0).(func(context.Context, string, bool, string, string, string, map[string]interface{}, bool) error); ok { + r0 = rf(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, enableRanks) } else { r0 = ret.Error(0) } @@ -1128,10 +2694,49 @@ func (_m *MockNakamaModule) LeaderboardCreate(ctx context.Context, id string, au return r0 } +// MockNakamaModule_LeaderboardCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardCreate' +type MockNakamaModule_LeaderboardCreate_Call struct { + *mock.Call +} + +// LeaderboardCreate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - authoritative bool +// - sortOrder string +// - operator string +// - resetSchedule string +// - metadata map[string]interface{} +// - enableRanks bool +func (_e *MockNakamaModule_Expecter) LeaderboardCreate(ctx interface{}, id interface{}, authoritative interface{}, sortOrder interface{}, operator interface{}, resetSchedule interface{}, metadata interface{}, enableRanks interface{}) *MockNakamaModule_LeaderboardCreate_Call { + return &MockNakamaModule_LeaderboardCreate_Call{Call: _e.mock.On("LeaderboardCreate", ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, enableRanks)} +} + +func (_c *MockNakamaModule_LeaderboardCreate_Call) Run(run func(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}, enableRanks bool)) *MockNakamaModule_LeaderboardCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(bool), args[3].(string), args[4].(string), args[5].(string), args[6].(map[string]interface{}), args[7].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardCreate_Call) Return(_a0 error) *MockNakamaModule_LeaderboardCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LeaderboardCreate_Call) RunAndReturn(run func(context.Context, string, bool, string, string, string, map[string]interface{}, bool) error) *MockNakamaModule_LeaderboardCreate_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardDelete provides a mock function with given fields: ctx, id func (_m *MockNakamaModule) LeaderboardDelete(ctx context.Context, id string) error { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for LeaderboardDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, id) @@ -1142,10 +2747,43 @@ func (_m *MockNakamaModule) LeaderboardDelete(ctx context.Context, id string) er return r0 } +// MockNakamaModule_LeaderboardDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardDelete' +type MockNakamaModule_LeaderboardDelete_Call struct { + *mock.Call +} + +// LeaderboardDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) LeaderboardDelete(ctx interface{}, id interface{}) *MockNakamaModule_LeaderboardDelete_Call { + return &MockNakamaModule_LeaderboardDelete_Call{Call: _e.mock.On("LeaderboardDelete", ctx, id)} +} + +func (_c *MockNakamaModule_LeaderboardDelete_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_LeaderboardDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardDelete_Call) Return(_a0 error) *MockNakamaModule_LeaderboardDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LeaderboardDelete_Call) RunAndReturn(run func(context.Context, string) error) *MockNakamaModule_LeaderboardDelete_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardList provides a mock function with given fields: limit, cursor func (_m *MockNakamaModule) LeaderboardList(limit int, cursor string) (*api.LeaderboardList, error) { ret := _m.Called(limit, cursor) + if len(ret) == 0 { + panic("no return value specified for LeaderboardList") + } + var r0 *api.LeaderboardList var r1 error if rf, ok := ret.Get(0).(func(int, string) (*api.LeaderboardList, error)); ok { @@ -1168,10 +2806,90 @@ func (_m *MockNakamaModule) LeaderboardList(limit int, cursor string) (*api.Lead return r0, r1 } +// MockNakamaModule_LeaderboardList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardList' +type MockNakamaModule_LeaderboardList_Call struct { + *mock.Call +} + +// LeaderboardList is a helper method to define mock.On call +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) LeaderboardList(limit interface{}, cursor interface{}) *MockNakamaModule_LeaderboardList_Call { + return &MockNakamaModule_LeaderboardList_Call{Call: _e.mock.On("LeaderboardList", limit, cursor)} +} + +func (_c *MockNakamaModule_LeaderboardList_Call) Run(run func(limit int, cursor string)) *MockNakamaModule_LeaderboardList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardList_Call) Return(_a0 *api.LeaderboardList, _a1 error) *MockNakamaModule_LeaderboardList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_LeaderboardList_Call) RunAndReturn(run func(int, string) (*api.LeaderboardList, error)) *MockNakamaModule_LeaderboardList_Call { + _c.Call.Return(run) + return _c +} + +// LeaderboardRanksDisable provides a mock function with given fields: ctx, id +func (_m *MockNakamaModule) LeaderboardRanksDisable(ctx context.Context, id string) error { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for LeaderboardRanksDisable") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_LeaderboardRanksDisable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRanksDisable' +type MockNakamaModule_LeaderboardRanksDisable_Call struct { + *mock.Call +} + +// LeaderboardRanksDisable is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) LeaderboardRanksDisable(ctx interface{}, id interface{}) *MockNakamaModule_LeaderboardRanksDisable_Call { + return &MockNakamaModule_LeaderboardRanksDisable_Call{Call: _e.mock.On("LeaderboardRanksDisable", ctx, id)} +} + +func (_c *MockNakamaModule_LeaderboardRanksDisable_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_LeaderboardRanksDisable_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRanksDisable_Call) Return(_a0 error) *MockNakamaModule_LeaderboardRanksDisable_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRanksDisable_Call) RunAndReturn(run func(context.Context, string) error) *MockNakamaModule_LeaderboardRanksDisable_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardRecordDelete provides a mock function with given fields: ctx, id, ownerID func (_m *MockNakamaModule) LeaderboardRecordDelete(ctx context.Context, id string, ownerID string) error { ret := _m.Called(ctx, id, ownerID) + if len(ret) == 0 { + panic("no return value specified for LeaderboardRecordDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, id, ownerID) @@ -1182,10 +2900,44 @@ func (_m *MockNakamaModule) LeaderboardRecordDelete(ctx context.Context, id stri return r0 } +// MockNakamaModule_LeaderboardRecordDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRecordDelete' +type MockNakamaModule_LeaderboardRecordDelete_Call struct { + *mock.Call +} + +// LeaderboardRecordDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +func (_e *MockNakamaModule_Expecter) LeaderboardRecordDelete(ctx interface{}, id interface{}, ownerID interface{}) *MockNakamaModule_LeaderboardRecordDelete_Call { + return &MockNakamaModule_LeaderboardRecordDelete_Call{Call: _e.mock.On("LeaderboardRecordDelete", ctx, id, ownerID)} +} + +func (_c *MockNakamaModule_LeaderboardRecordDelete_Call) Run(run func(ctx context.Context, id string, ownerID string)) *MockNakamaModule_LeaderboardRecordDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordDelete_Call) Return(_a0 error) *MockNakamaModule_LeaderboardRecordDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordDelete_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LeaderboardRecordDelete_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardRecordWrite provides a mock function with given fields: ctx, id, ownerID, username, score, subscore, metadata, overrideOperator func (_m *MockNakamaModule) LeaderboardRecordWrite(ctx context.Context, id string, ownerID string, username string, score int64, subscore int64, metadata map[string]interface{}, overrideOperator *int) (*api.LeaderboardRecord, error) { ret := _m.Called(ctx, id, ownerID, username, score, subscore, metadata, overrideOperator) + if len(ret) == 0 { + panic("no return value specified for LeaderboardRecordWrite") + } + var r0 *api.LeaderboardRecord var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, int64, map[string]interface{}, *int) (*api.LeaderboardRecord, error)); ok { @@ -1208,10 +2960,49 @@ func (_m *MockNakamaModule) LeaderboardRecordWrite(ctx context.Context, id strin return r0, r1 } +// MockNakamaModule_LeaderboardRecordWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRecordWrite' +type MockNakamaModule_LeaderboardRecordWrite_Call struct { + *mock.Call +} + +// LeaderboardRecordWrite is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - username string +// - score int64 +// - subscore int64 +// - metadata map[string]interface{} +// - overrideOperator *int +func (_e *MockNakamaModule_Expecter) LeaderboardRecordWrite(ctx interface{}, id interface{}, ownerID interface{}, username interface{}, score interface{}, subscore interface{}, metadata interface{}, overrideOperator interface{}) *MockNakamaModule_LeaderboardRecordWrite_Call { + return &MockNakamaModule_LeaderboardRecordWrite_Call{Call: _e.mock.On("LeaderboardRecordWrite", ctx, id, ownerID, username, score, subscore, metadata, overrideOperator)} +} + +func (_c *MockNakamaModule_LeaderboardRecordWrite_Call) Run(run func(ctx context.Context, id string, ownerID string, username string, score int64, subscore int64, metadata map[string]interface{}, overrideOperator *int)) *MockNakamaModule_LeaderboardRecordWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64), args[5].(int64), args[6].(map[string]interface{}), args[7].(*int)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordWrite_Call) Return(_a0 *api.LeaderboardRecord, _a1 error) *MockNakamaModule_LeaderboardRecordWrite_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordWrite_Call) RunAndReturn(run func(context.Context, string, string, string, int64, int64, map[string]interface{}, *int) (*api.LeaderboardRecord, error)) *MockNakamaModule_LeaderboardRecordWrite_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardRecordsHaystack provides a mock function with given fields: ctx, id, ownerID, limit, cursor, expiry func (_m *MockNakamaModule) LeaderboardRecordsHaystack(ctx context.Context, id string, ownerID string, limit int, cursor string, expiry int64) (*api.LeaderboardRecordList, error) { ret := _m.Called(ctx, id, ownerID, limit, cursor, expiry) + if len(ret) == 0 { + panic("no return value specified for LeaderboardRecordsHaystack") + } + var r0 *api.LeaderboardRecordList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, int, string, int64) (*api.LeaderboardRecordList, error)); ok { @@ -1234,10 +3025,47 @@ func (_m *MockNakamaModule) LeaderboardRecordsHaystack(ctx context.Context, id s return r0, r1 } +// MockNakamaModule_LeaderboardRecordsHaystack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRecordsHaystack' +type MockNakamaModule_LeaderboardRecordsHaystack_Call struct { + *mock.Call +} + +// LeaderboardRecordsHaystack is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - limit int +// - cursor string +// - expiry int64 +func (_e *MockNakamaModule_Expecter) LeaderboardRecordsHaystack(ctx interface{}, id interface{}, ownerID interface{}, limit interface{}, cursor interface{}, expiry interface{}) *MockNakamaModule_LeaderboardRecordsHaystack_Call { + return &MockNakamaModule_LeaderboardRecordsHaystack_Call{Call: _e.mock.On("LeaderboardRecordsHaystack", ctx, id, ownerID, limit, cursor, expiry)} +} + +func (_c *MockNakamaModule_LeaderboardRecordsHaystack_Call) Run(run func(ctx context.Context, id string, ownerID string, limit int, cursor string, expiry int64)) *MockNakamaModule_LeaderboardRecordsHaystack_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(string), args[5].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsHaystack_Call) Return(_a0 *api.LeaderboardRecordList, _a1 error) *MockNakamaModule_LeaderboardRecordsHaystack_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsHaystack_Call) RunAndReturn(run func(context.Context, string, string, int, string, int64) (*api.LeaderboardRecordList, error)) *MockNakamaModule_LeaderboardRecordsHaystack_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardRecordsList provides a mock function with given fields: ctx, id, ownerIDs, limit, cursor, expiry func (_m *MockNakamaModule) LeaderboardRecordsList(ctx context.Context, id string, ownerIDs []string, limit int, cursor string, expiry int64) ([]*api.LeaderboardRecord, []*api.LeaderboardRecord, string, string, error) { ret := _m.Called(ctx, id, ownerIDs, limit, cursor, expiry) + if len(ret) == 0 { + panic("no return value specified for LeaderboardRecordsList") + } + var r0 []*api.LeaderboardRecord var r1 []*api.LeaderboardRecord var r2 string @@ -1283,10 +3111,47 @@ func (_m *MockNakamaModule) LeaderboardRecordsList(ctx context.Context, id strin return r0, r1, r2, r3, r4 } +// MockNakamaModule_LeaderboardRecordsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRecordsList' +type MockNakamaModule_LeaderboardRecordsList_Call struct { + *mock.Call +} + +// LeaderboardRecordsList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerIDs []string +// - limit int +// - cursor string +// - expiry int64 +func (_e *MockNakamaModule_Expecter) LeaderboardRecordsList(ctx interface{}, id interface{}, ownerIDs interface{}, limit interface{}, cursor interface{}, expiry interface{}) *MockNakamaModule_LeaderboardRecordsList_Call { + return &MockNakamaModule_LeaderboardRecordsList_Call{Call: _e.mock.On("LeaderboardRecordsList", ctx, id, ownerIDs, limit, cursor, expiry)} +} + +func (_c *MockNakamaModule_LeaderboardRecordsList_Call) Run(run func(ctx context.Context, id string, ownerIDs []string, limit int, cursor string, expiry int64)) *MockNakamaModule_LeaderboardRecordsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(int), args[4].(string), args[5].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsList_Call) Return(records []*api.LeaderboardRecord, ownerRecords []*api.LeaderboardRecord, nextCursor string, prevCursor string, err error) *MockNakamaModule_LeaderboardRecordsList_Call { + _c.Call.Return(records, ownerRecords, nextCursor, prevCursor, err) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsList_Call) RunAndReturn(run func(context.Context, string, []string, int, string, int64) ([]*api.LeaderboardRecord, []*api.LeaderboardRecord, string, string, error)) *MockNakamaModule_LeaderboardRecordsList_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardRecordsListCursorFromRank provides a mock function with given fields: id, rank, overrideExpiry func (_m *MockNakamaModule) LeaderboardRecordsListCursorFromRank(id string, rank int64, overrideExpiry int64) (string, error) { ret := _m.Called(id, rank, overrideExpiry) + if len(ret) == 0 { + panic("no return value specified for LeaderboardRecordsListCursorFromRank") + } + var r0 string var r1 error if rf, ok := ret.Get(0).(func(string, int64, int64) (string, error)); ok { @@ -1307,10 +3172,44 @@ func (_m *MockNakamaModule) LeaderboardRecordsListCursorFromRank(id string, rank return r0, r1 } +// MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardRecordsListCursorFromRank' +type MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call struct { + *mock.Call +} + +// LeaderboardRecordsListCursorFromRank is a helper method to define mock.On call +// - id string +// - rank int64 +// - overrideExpiry int64 +func (_e *MockNakamaModule_Expecter) LeaderboardRecordsListCursorFromRank(id interface{}, rank interface{}, overrideExpiry interface{}) *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call { + return &MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call{Call: _e.mock.On("LeaderboardRecordsListCursorFromRank", id, rank, overrideExpiry)} +} + +func (_c *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call) Run(run func(id string, rank int64, overrideExpiry int64)) *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int64), args[2].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call) Return(_a0 string, _a1 error) *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call) RunAndReturn(run func(string, int64, int64) (string, error)) *MockNakamaModule_LeaderboardRecordsListCursorFromRank_Call { + _c.Call.Return(run) + return _c +} + // LeaderboardsGetId provides a mock function with given fields: ctx, ids func (_m *MockNakamaModule) LeaderboardsGetId(ctx context.Context, ids []string) ([]*api.Leaderboard, error) { ret := _m.Called(ctx, ids) + if len(ret) == 0 { + panic("no return value specified for LeaderboardsGetId") + } + var r0 []*api.Leaderboard var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*api.Leaderboard, error)); ok { @@ -1333,10 +3232,43 @@ func (_m *MockNakamaModule) LeaderboardsGetId(ctx context.Context, ids []string) return r0, r1 } +// MockNakamaModule_LeaderboardsGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaderboardsGetId' +type MockNakamaModule_LeaderboardsGetId_Call struct { + *mock.Call +} + +// LeaderboardsGetId is a helper method to define mock.On call +// - ctx context.Context +// - ids []string +func (_e *MockNakamaModule_Expecter) LeaderboardsGetId(ctx interface{}, ids interface{}) *MockNakamaModule_LeaderboardsGetId_Call { + return &MockNakamaModule_LeaderboardsGetId_Call{Call: _e.mock.On("LeaderboardsGetId", ctx, ids)} +} + +func (_c *MockNakamaModule_LeaderboardsGetId_Call) Run(run func(ctx context.Context, ids []string)) *MockNakamaModule_LeaderboardsGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_LeaderboardsGetId_Call) Return(_a0 []*api.Leaderboard, _a1 error) *MockNakamaModule_LeaderboardsGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_LeaderboardsGetId_Call) RunAndReturn(run func(context.Context, []string) ([]*api.Leaderboard, error)) *MockNakamaModule_LeaderboardsGetId_Call { + _c.Call.Return(run) + return _c +} + // LinkApple provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) LinkApple(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) + if len(ret) == 0 { + panic("no return value specified for LinkApple") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, token) @@ -1347,10 +3279,44 @@ func (_m *MockNakamaModule) LinkApple(ctx context.Context, userID string, token return r0 } +// MockNakamaModule_LinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkApple' +type MockNakamaModule_LinkApple_Call struct { + *mock.Call +} + +// LinkApple is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) LinkApple(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_LinkApple_Call { + return &MockNakamaModule_LinkApple_Call{Call: _e.mock.On("LinkApple", ctx, userID, token)} +} + +func (_c *MockNakamaModule_LinkApple_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_LinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkApple_Call) Return(_a0 error) *MockNakamaModule_LinkApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkApple_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LinkApple_Call { + _c.Call.Return(run) + return _c +} + // LinkCustom provides a mock function with given fields: ctx, userID, customID func (_m *MockNakamaModule) LinkCustom(ctx context.Context, userID string, customID string) error { ret := _m.Called(ctx, userID, customID) + if len(ret) == 0 { + panic("no return value specified for LinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, customID) @@ -1361,10 +3327,44 @@ func (_m *MockNakamaModule) LinkCustom(ctx context.Context, userID string, custo return r0 } +// MockNakamaModule_LinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkCustom' +type MockNakamaModule_LinkCustom_Call struct { + *mock.Call +} + +// LinkCustom is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - customID string +func (_e *MockNakamaModule_Expecter) LinkCustom(ctx interface{}, userID interface{}, customID interface{}) *MockNakamaModule_LinkCustom_Call { + return &MockNakamaModule_LinkCustom_Call{Call: _e.mock.On("LinkCustom", ctx, userID, customID)} +} + +func (_c *MockNakamaModule_LinkCustom_Call) Run(run func(ctx context.Context, userID string, customID string)) *MockNakamaModule_LinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkCustom_Call) Return(_a0 error) *MockNakamaModule_LinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkCustom_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LinkCustom_Call { + _c.Call.Return(run) + return _c +} + // LinkDevice provides a mock function with given fields: ctx, userID, deviceID func (_m *MockNakamaModule) LinkDevice(ctx context.Context, userID string, deviceID string) error { ret := _m.Called(ctx, userID, deviceID) + if len(ret) == 0 { + panic("no return value specified for LinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, deviceID) @@ -1375,10 +3375,44 @@ func (_m *MockNakamaModule) LinkDevice(ctx context.Context, userID string, devic return r0 } +// MockNakamaModule_LinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkDevice' +type MockNakamaModule_LinkDevice_Call struct { + *mock.Call +} + +// LinkDevice is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - deviceID string +func (_e *MockNakamaModule_Expecter) LinkDevice(ctx interface{}, userID interface{}, deviceID interface{}) *MockNakamaModule_LinkDevice_Call { + return &MockNakamaModule_LinkDevice_Call{Call: _e.mock.On("LinkDevice", ctx, userID, deviceID)} +} + +func (_c *MockNakamaModule_LinkDevice_Call) Run(run func(ctx context.Context, userID string, deviceID string)) *MockNakamaModule_LinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkDevice_Call) Return(_a0 error) *MockNakamaModule_LinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkDevice_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LinkDevice_Call { + _c.Call.Return(run) + return _c +} + // LinkEmail provides a mock function with given fields: ctx, userID, email, password func (_m *MockNakamaModule) LinkEmail(ctx context.Context, userID string, email string, password string) error { ret := _m.Called(ctx, userID, email, password) + if len(ret) == 0 { + panic("no return value specified for LinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { r0 = rf(ctx, userID, email, password) @@ -1389,10 +3423,45 @@ func (_m *MockNakamaModule) LinkEmail(ctx context.Context, userID string, email return r0 } +// MockNakamaModule_LinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkEmail' +type MockNakamaModule_LinkEmail_Call struct { + *mock.Call +} + +// LinkEmail is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - email string +// - password string +func (_e *MockNakamaModule_Expecter) LinkEmail(ctx interface{}, userID interface{}, email interface{}, password interface{}) *MockNakamaModule_LinkEmail_Call { + return &MockNakamaModule_LinkEmail_Call{Call: _e.mock.On("LinkEmail", ctx, userID, email, password)} +} + +func (_c *MockNakamaModule_LinkEmail_Call) Run(run func(ctx context.Context, userID string, email string, password string)) *MockNakamaModule_LinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkEmail_Call) Return(_a0 error) *MockNakamaModule_LinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkEmail_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockNakamaModule_LinkEmail_Call { + _c.Call.Return(run) + return _c +} + // LinkFacebook provides a mock function with given fields: ctx, userID, username, token, importFriends func (_m *MockNakamaModule) LinkFacebook(ctx context.Context, userID string, username string, token string, importFriends bool) error { ret := _m.Called(ctx, userID, username, token, importFriends) + if len(ret) == 0 { + panic("no return value specified for LinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, bool) error); ok { r0 = rf(ctx, userID, username, token, importFriends) @@ -1403,10 +3472,46 @@ func (_m *MockNakamaModule) LinkFacebook(ctx context.Context, userID string, use return r0 } +// MockNakamaModule_LinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkFacebook' +type MockNakamaModule_LinkFacebook_Call struct { + *mock.Call +} + +// LinkFacebook is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - token string +// - importFriends bool +func (_e *MockNakamaModule_Expecter) LinkFacebook(ctx interface{}, userID interface{}, username interface{}, token interface{}, importFriends interface{}) *MockNakamaModule_LinkFacebook_Call { + return &MockNakamaModule_LinkFacebook_Call{Call: _e.mock.On("LinkFacebook", ctx, userID, username, token, importFriends)} +} + +func (_c *MockNakamaModule_LinkFacebook_Call) Run(run func(ctx context.Context, userID string, username string, token string, importFriends bool)) *MockNakamaModule_LinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkFacebook_Call) Return(_a0 error) *MockNakamaModule_LinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkFacebook_Call) RunAndReturn(run func(context.Context, string, string, string, bool) error) *MockNakamaModule_LinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // LinkFacebookInstantGame provides a mock function with given fields: ctx, userID, signedPlayerInfo func (_m *MockNakamaModule) LinkFacebookInstantGame(ctx context.Context, userID string, signedPlayerInfo string) error { ret := _m.Called(ctx, userID, signedPlayerInfo) + if len(ret) == 0 { + panic("no return value specified for LinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, signedPlayerInfo) @@ -1417,10 +3522,44 @@ func (_m *MockNakamaModule) LinkFacebookInstantGame(ctx context.Context, userID return r0 } +// MockNakamaModule_LinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkFacebookInstantGame' +type MockNakamaModule_LinkFacebookInstantGame_Call struct { + *mock.Call +} + +// LinkFacebookInstantGame is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - signedPlayerInfo string +func (_e *MockNakamaModule_Expecter) LinkFacebookInstantGame(ctx interface{}, userID interface{}, signedPlayerInfo interface{}) *MockNakamaModule_LinkFacebookInstantGame_Call { + return &MockNakamaModule_LinkFacebookInstantGame_Call{Call: _e.mock.On("LinkFacebookInstantGame", ctx, userID, signedPlayerInfo)} +} + +func (_c *MockNakamaModule_LinkFacebookInstantGame_Call) Run(run func(ctx context.Context, userID string, signedPlayerInfo string)) *MockNakamaModule_LinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkFacebookInstantGame_Call) Return(_a0 error) *MockNakamaModule_LinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkFacebookInstantGame_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // LinkGameCenter provides a mock function with given fields: ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl func (_m *MockNakamaModule) LinkGameCenter(ctx context.Context, userID string, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string) error { ret := _m.Called(ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl) + if len(ret) == 0 { + panic("no return value specified for LinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, string, string, string) error); ok { r0 = rf(ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl) @@ -1431,10 +3570,49 @@ func (_m *MockNakamaModule) LinkGameCenter(ctx context.Context, userID string, p return r0 } +// MockNakamaModule_LinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkGameCenter' +type MockNakamaModule_LinkGameCenter_Call struct { + *mock.Call +} + +// LinkGameCenter is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - playerID string +// - bundleID string +// - timestamp int64 +// - salt string +// - signature string +// - publicKeyUrl string +func (_e *MockNakamaModule_Expecter) LinkGameCenter(ctx interface{}, userID interface{}, playerID interface{}, bundleID interface{}, timestamp interface{}, salt interface{}, signature interface{}, publicKeyUrl interface{}) *MockNakamaModule_LinkGameCenter_Call { + return &MockNakamaModule_LinkGameCenter_Call{Call: _e.mock.On("LinkGameCenter", ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl)} +} + +func (_c *MockNakamaModule_LinkGameCenter_Call) Run(run func(ctx context.Context, userID string, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string)) *MockNakamaModule_LinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64), args[5].(string), args[6].(string), args[7].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkGameCenter_Call) Return(_a0 error) *MockNakamaModule_LinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkGameCenter_Call) RunAndReturn(run func(context.Context, string, string, string, int64, string, string, string) error) *MockNakamaModule_LinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // LinkGoogle provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) LinkGoogle(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) + if len(ret) == 0 { + panic("no return value specified for LinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, token) @@ -1445,10 +3623,44 @@ func (_m *MockNakamaModule) LinkGoogle(ctx context.Context, userID string, token return r0 } +// MockNakamaModule_LinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkGoogle' +type MockNakamaModule_LinkGoogle_Call struct { + *mock.Call +} + +// LinkGoogle is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) LinkGoogle(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_LinkGoogle_Call { + return &MockNakamaModule_LinkGoogle_Call{Call: _e.mock.On("LinkGoogle", ctx, userID, token)} +} + +func (_c *MockNakamaModule_LinkGoogle_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_LinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkGoogle_Call) Return(_a0 error) *MockNakamaModule_LinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkGoogle_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_LinkGoogle_Call { + _c.Call.Return(run) + return _c +} + // LinkSteam provides a mock function with given fields: ctx, userID, username, token, importFriends func (_m *MockNakamaModule) LinkSteam(ctx context.Context, userID string, username string, token string, importFriends bool) error { ret := _m.Called(ctx, userID, username, token, importFriends) + if len(ret) == 0 { + panic("no return value specified for LinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, bool) error); ok { r0 = rf(ctx, userID, username, token, importFriends) @@ -1459,10 +3671,46 @@ func (_m *MockNakamaModule) LinkSteam(ctx context.Context, userID string, userna return r0 } -// MatchCreate provides a mock function with given fields: ctx, module, params -func (_m *MockNakamaModule) MatchCreate(ctx context.Context, module string, params map[string]interface{}) (string, error) { +// MockNakamaModule_LinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkSteam' +type MockNakamaModule_LinkSteam_Call struct { + *mock.Call +} + +// LinkSteam is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - username string +// - token string +// - importFriends bool +func (_e *MockNakamaModule_Expecter) LinkSteam(ctx interface{}, userID interface{}, username interface{}, token interface{}, importFriends interface{}) *MockNakamaModule_LinkSteam_Call { + return &MockNakamaModule_LinkSteam_Call{Call: _e.mock.On("LinkSteam", ctx, userID, username, token, importFriends)} +} + +func (_c *MockNakamaModule_LinkSteam_Call) Run(run func(ctx context.Context, userID string, username string, token string, importFriends bool)) *MockNakamaModule_LinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_LinkSteam_Call) Return(_a0 error) *MockNakamaModule_LinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_LinkSteam_Call) RunAndReturn(run func(context.Context, string, string, string, bool) error) *MockNakamaModule_LinkSteam_Call { + _c.Call.Return(run) + return _c +} + +// MatchCreate provides a mock function with given fields: ctx, module, params +func (_m *MockNakamaModule) MatchCreate(ctx context.Context, module string, params map[string]interface{}) (string, error) { ret := _m.Called(ctx, module, params) + if len(ret) == 0 { + panic("no return value specified for MatchCreate") + } + var r0 string var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, map[string]interface{}) (string, error)); ok { @@ -1483,10 +3731,44 @@ func (_m *MockNakamaModule) MatchCreate(ctx context.Context, module string, para return r0, r1 } +// MockNakamaModule_MatchCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchCreate' +type MockNakamaModule_MatchCreate_Call struct { + *mock.Call +} + +// MatchCreate is a helper method to define mock.On call +// - ctx context.Context +// - module string +// - params map[string]interface{} +func (_e *MockNakamaModule_Expecter) MatchCreate(ctx interface{}, module interface{}, params interface{}) *MockNakamaModule_MatchCreate_Call { + return &MockNakamaModule_MatchCreate_Call{Call: _e.mock.On("MatchCreate", ctx, module, params)} +} + +func (_c *MockNakamaModule_MatchCreate_Call) Run(run func(ctx context.Context, module string, params map[string]interface{})) *MockNakamaModule_MatchCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *MockNakamaModule_MatchCreate_Call) Return(_a0 string, _a1 error) *MockNakamaModule_MatchCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_MatchCreate_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}) (string, error)) *MockNakamaModule_MatchCreate_Call { + _c.Call.Return(run) + return _c +} + // MatchGet provides a mock function with given fields: ctx, id func (_m *MockNakamaModule) MatchGet(ctx context.Context, id string) (*api.Match, error) { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for MatchGet") + } + var r0 *api.Match var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*api.Match, error)); ok { @@ -1509,10 +3791,43 @@ func (_m *MockNakamaModule) MatchGet(ctx context.Context, id string) (*api.Match return r0, r1 } +// MockNakamaModule_MatchGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchGet' +type MockNakamaModule_MatchGet_Call struct { + *mock.Call +} + +// MatchGet is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) MatchGet(ctx interface{}, id interface{}) *MockNakamaModule_MatchGet_Call { + return &MockNakamaModule_MatchGet_Call{Call: _e.mock.On("MatchGet", ctx, id)} +} + +func (_c *MockNakamaModule_MatchGet_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_MatchGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_MatchGet_Call) Return(_a0 *api.Match, _a1 error) *MockNakamaModule_MatchGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_MatchGet_Call) RunAndReturn(run func(context.Context, string) (*api.Match, error)) *MockNakamaModule_MatchGet_Call { + _c.Call.Return(run) + return _c +} + // MatchList provides a mock function with given fields: ctx, limit, authoritative, label, minSize, maxSize, query func (_m *MockNakamaModule) MatchList(ctx context.Context, limit int, authoritative bool, label string, minSize *int, maxSize *int, query string) ([]*api.Match, error) { ret := _m.Called(ctx, limit, authoritative, label, minSize, maxSize, query) + if len(ret) == 0 { + panic("no return value specified for MatchList") + } + var r0 []*api.Match var r1 error if rf, ok := ret.Get(0).(func(context.Context, int, bool, string, *int, *int, string) ([]*api.Match, error)); ok { @@ -1535,10 +3850,48 @@ func (_m *MockNakamaModule) MatchList(ctx context.Context, limit int, authoritat return r0, r1 } +// MockNakamaModule_MatchList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchList' +type MockNakamaModule_MatchList_Call struct { + *mock.Call +} + +// MatchList is a helper method to define mock.On call +// - ctx context.Context +// - limit int +// - authoritative bool +// - label string +// - minSize *int +// - maxSize *int +// - query string +func (_e *MockNakamaModule_Expecter) MatchList(ctx interface{}, limit interface{}, authoritative interface{}, label interface{}, minSize interface{}, maxSize interface{}, query interface{}) *MockNakamaModule_MatchList_Call { + return &MockNakamaModule_MatchList_Call{Call: _e.mock.On("MatchList", ctx, limit, authoritative, label, minSize, maxSize, query)} +} + +func (_c *MockNakamaModule_MatchList_Call) Run(run func(ctx context.Context, limit int, authoritative bool, label string, minSize *int, maxSize *int, query string)) *MockNakamaModule_MatchList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(bool), args[3].(string), args[4].(*int), args[5].(*int), args[6].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_MatchList_Call) Return(_a0 []*api.Match, _a1 error) *MockNakamaModule_MatchList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_MatchList_Call) RunAndReturn(run func(context.Context, int, bool, string, *int, *int, string) ([]*api.Match, error)) *MockNakamaModule_MatchList_Call { + _c.Call.Return(run) + return _c +} + // MatchSignal provides a mock function with given fields: ctx, id, data func (_m *MockNakamaModule) MatchSignal(ctx context.Context, id string, data string) (string, error) { ret := _m.Called(ctx, id, data) + if len(ret) == 0 { + panic("no return value specified for MatchSignal") + } + var r0 string var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok { @@ -1559,25 +3912,149 @@ func (_m *MockNakamaModule) MatchSignal(ctx context.Context, id string, data str return r0, r1 } +// MockNakamaModule_MatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MatchSignal' +type MockNakamaModule_MatchSignal_Call struct { + *mock.Call +} + +// MatchSignal is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - data string +func (_e *MockNakamaModule_Expecter) MatchSignal(ctx interface{}, id interface{}, data interface{}) *MockNakamaModule_MatchSignal_Call { + return &MockNakamaModule_MatchSignal_Call{Call: _e.mock.On("MatchSignal", ctx, id, data)} +} + +func (_c *MockNakamaModule_MatchSignal_Call) Run(run func(ctx context.Context, id string, data string)) *MockNakamaModule_MatchSignal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_MatchSignal_Call) Return(_a0 string, _a1 error) *MockNakamaModule_MatchSignal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_MatchSignal_Call) RunAndReturn(run func(context.Context, string, string) (string, error)) *MockNakamaModule_MatchSignal_Call { + _c.Call.Return(run) + return _c +} + // MetricsCounterAdd provides a mock function with given fields: name, tags, delta func (_m *MockNakamaModule) MetricsCounterAdd(name string, tags map[string]string, delta int64) { _m.Called(name, tags, delta) } +// MockNakamaModule_MetricsCounterAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MetricsCounterAdd' +type MockNakamaModule_MetricsCounterAdd_Call struct { + *mock.Call +} + +// MetricsCounterAdd is a helper method to define mock.On call +// - name string +// - tags map[string]string +// - delta int64 +func (_e *MockNakamaModule_Expecter) MetricsCounterAdd(name interface{}, tags interface{}, delta interface{}) *MockNakamaModule_MetricsCounterAdd_Call { + return &MockNakamaModule_MetricsCounterAdd_Call{Call: _e.mock.On("MetricsCounterAdd", name, tags, delta)} +} + +func (_c *MockNakamaModule_MetricsCounterAdd_Call) Run(run func(name string, tags map[string]string, delta int64)) *MockNakamaModule_MetricsCounterAdd_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(map[string]string), args[2].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_MetricsCounterAdd_Call) Return() *MockNakamaModule_MetricsCounterAdd_Call { + _c.Call.Return() + return _c +} + +func (_c *MockNakamaModule_MetricsCounterAdd_Call) RunAndReturn(run func(string, map[string]string, int64)) *MockNakamaModule_MetricsCounterAdd_Call { + _c.Run(run) + return _c +} + // MetricsGaugeSet provides a mock function with given fields: name, tags, value func (_m *MockNakamaModule) MetricsGaugeSet(name string, tags map[string]string, value float64) { _m.Called(name, tags, value) } +// MockNakamaModule_MetricsGaugeSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MetricsGaugeSet' +type MockNakamaModule_MetricsGaugeSet_Call struct { + *mock.Call +} + +// MetricsGaugeSet is a helper method to define mock.On call +// - name string +// - tags map[string]string +// - value float64 +func (_e *MockNakamaModule_Expecter) MetricsGaugeSet(name interface{}, tags interface{}, value interface{}) *MockNakamaModule_MetricsGaugeSet_Call { + return &MockNakamaModule_MetricsGaugeSet_Call{Call: _e.mock.On("MetricsGaugeSet", name, tags, value)} +} + +func (_c *MockNakamaModule_MetricsGaugeSet_Call) Run(run func(name string, tags map[string]string, value float64)) *MockNakamaModule_MetricsGaugeSet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(map[string]string), args[2].(float64)) + }) + return _c +} + +func (_c *MockNakamaModule_MetricsGaugeSet_Call) Return() *MockNakamaModule_MetricsGaugeSet_Call { + _c.Call.Return() + return _c +} + +func (_c *MockNakamaModule_MetricsGaugeSet_Call) RunAndReturn(run func(string, map[string]string, float64)) *MockNakamaModule_MetricsGaugeSet_Call { + _c.Run(run) + return _c +} + // MetricsTimerRecord provides a mock function with given fields: name, tags, value func (_m *MockNakamaModule) MetricsTimerRecord(name string, tags map[string]string, value time.Duration) { _m.Called(name, tags, value) } +// MockNakamaModule_MetricsTimerRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MetricsTimerRecord' +type MockNakamaModule_MetricsTimerRecord_Call struct { + *mock.Call +} + +// MetricsTimerRecord is a helper method to define mock.On call +// - name string +// - tags map[string]string +// - value time.Duration +func (_e *MockNakamaModule_Expecter) MetricsTimerRecord(name interface{}, tags interface{}, value interface{}) *MockNakamaModule_MetricsTimerRecord_Call { + return &MockNakamaModule_MetricsTimerRecord_Call{Call: _e.mock.On("MetricsTimerRecord", name, tags, value)} +} + +func (_c *MockNakamaModule_MetricsTimerRecord_Call) Run(run func(name string, tags map[string]string, value time.Duration)) *MockNakamaModule_MetricsTimerRecord_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(map[string]string), args[2].(time.Duration)) + }) + return _c +} + +func (_c *MockNakamaModule_MetricsTimerRecord_Call) Return() *MockNakamaModule_MetricsTimerRecord_Call { + _c.Call.Return() + return _c +} + +func (_c *MockNakamaModule_MetricsTimerRecord_Call) RunAndReturn(run func(string, map[string]string, time.Duration)) *MockNakamaModule_MetricsTimerRecord_Call { + _c.Run(run) + return _c +} + // MultiUpdate provides a mock function with given fields: ctx, accountUpdates, storageWrites, storageDeletes, walletUpdates, updateLedger func (_m *MockNakamaModule) MultiUpdate(ctx context.Context, accountUpdates []*runtime.AccountUpdate, storageWrites []*runtime.StorageWrite, storageDeletes []*runtime.StorageDelete, walletUpdates []*runtime.WalletUpdate, updateLedger bool) ([]*api.StorageObjectAck, []*runtime.WalletUpdateResult, error) { ret := _m.Called(ctx, accountUpdates, storageWrites, storageDeletes, walletUpdates, updateLedger) + if len(ret) == 0 { + panic("no return value specified for MultiUpdate") + } + var r0 []*api.StorageObjectAck var r1 []*runtime.WalletUpdateResult var r2 error @@ -1609,10 +4086,47 @@ func (_m *MockNakamaModule) MultiUpdate(ctx context.Context, accountUpdates []*r return r0, r1, r2 } +// MockNakamaModule_MultiUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiUpdate' +type MockNakamaModule_MultiUpdate_Call struct { + *mock.Call +} + +// MultiUpdate is a helper method to define mock.On call +// - ctx context.Context +// - accountUpdates []*runtime.AccountUpdate +// - storageWrites []*runtime.StorageWrite +// - storageDeletes []*runtime.StorageDelete +// - walletUpdates []*runtime.WalletUpdate +// - updateLedger bool +func (_e *MockNakamaModule_Expecter) MultiUpdate(ctx interface{}, accountUpdates interface{}, storageWrites interface{}, storageDeletes interface{}, walletUpdates interface{}, updateLedger interface{}) *MockNakamaModule_MultiUpdate_Call { + return &MockNakamaModule_MultiUpdate_Call{Call: _e.mock.On("MultiUpdate", ctx, accountUpdates, storageWrites, storageDeletes, walletUpdates, updateLedger)} +} + +func (_c *MockNakamaModule_MultiUpdate_Call) Run(run func(ctx context.Context, accountUpdates []*runtime.AccountUpdate, storageWrites []*runtime.StorageWrite, storageDeletes []*runtime.StorageDelete, walletUpdates []*runtime.WalletUpdate, updateLedger bool)) *MockNakamaModule_MultiUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.AccountUpdate), args[2].([]*runtime.StorageWrite), args[3].([]*runtime.StorageDelete), args[4].([]*runtime.WalletUpdate), args[5].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_MultiUpdate_Call) Return(_a0 []*api.StorageObjectAck, _a1 []*runtime.WalletUpdateResult, _a2 error) *MockNakamaModule_MultiUpdate_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_MultiUpdate_Call) RunAndReturn(run func(context.Context, []*runtime.AccountUpdate, []*runtime.StorageWrite, []*runtime.StorageDelete, []*runtime.WalletUpdate, bool) ([]*api.StorageObjectAck, []*runtime.WalletUpdateResult, error)) *MockNakamaModule_MultiUpdate_Call { + _c.Call.Return(run) + return _c +} + // NotificationSend provides a mock function with given fields: ctx, userID, subject, content, code, sender, persistent func (_m *MockNakamaModule) NotificationSend(ctx context.Context, userID string, subject string, content map[string]interface{}, code int, sender string, persistent bool) error { ret := _m.Called(ctx, userID, subject, content, code, sender, persistent) + if len(ret) == 0 { + panic("no return value specified for NotificationSend") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, map[string]interface{}, int, string, bool) error); ok { r0 = rf(ctx, userID, subject, content, code, sender, persistent) @@ -1623,10 +4137,48 @@ func (_m *MockNakamaModule) NotificationSend(ctx context.Context, userID string, return r0 } +// MockNakamaModule_NotificationSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationSend' +type MockNakamaModule_NotificationSend_Call struct { + *mock.Call +} + +// NotificationSend is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - subject string +// - content map[string]interface{} +// - code int +// - sender string +// - persistent bool +func (_e *MockNakamaModule_Expecter) NotificationSend(ctx interface{}, userID interface{}, subject interface{}, content interface{}, code interface{}, sender interface{}, persistent interface{}) *MockNakamaModule_NotificationSend_Call { + return &MockNakamaModule_NotificationSend_Call{Call: _e.mock.On("NotificationSend", ctx, userID, subject, content, code, sender, persistent)} +} + +func (_c *MockNakamaModule_NotificationSend_Call) Run(run func(ctx context.Context, userID string, subject string, content map[string]interface{}, code int, sender string, persistent bool)) *MockNakamaModule_NotificationSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(map[string]interface{}), args[4].(int), args[5].(string), args[6].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationSend_Call) Return(_a0 error) *MockNakamaModule_NotificationSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationSend_Call) RunAndReturn(run func(context.Context, string, string, map[string]interface{}, int, string, bool) error) *MockNakamaModule_NotificationSend_Call { + _c.Call.Return(run) + return _c +} + // NotificationSendAll provides a mock function with given fields: ctx, subject, content, code, persistent func (_m *MockNakamaModule) NotificationSendAll(ctx context.Context, subject string, content map[string]interface{}, code int, persistent bool) error { ret := _m.Called(ctx, subject, content, code, persistent) + if len(ret) == 0 { + panic("no return value specified for NotificationSendAll") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, map[string]interface{}, int, bool) error); ok { r0 = rf(ctx, subject, content, code, persistent) @@ -1637,10 +4189,46 @@ func (_m *MockNakamaModule) NotificationSendAll(ctx context.Context, subject str return r0 } +// MockNakamaModule_NotificationSendAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationSendAll' +type MockNakamaModule_NotificationSendAll_Call struct { + *mock.Call +} + +// NotificationSendAll is a helper method to define mock.On call +// - ctx context.Context +// - subject string +// - content map[string]interface{} +// - code int +// - persistent bool +func (_e *MockNakamaModule_Expecter) NotificationSendAll(ctx interface{}, subject interface{}, content interface{}, code interface{}, persistent interface{}) *MockNakamaModule_NotificationSendAll_Call { + return &MockNakamaModule_NotificationSendAll_Call{Call: _e.mock.On("NotificationSendAll", ctx, subject, content, code, persistent)} +} + +func (_c *MockNakamaModule_NotificationSendAll_Call) Run(run func(ctx context.Context, subject string, content map[string]interface{}, code int, persistent bool)) *MockNakamaModule_NotificationSendAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{}), args[3].(int), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationSendAll_Call) Return(_a0 error) *MockNakamaModule_NotificationSendAll_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationSendAll_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}, int, bool) error) *MockNakamaModule_NotificationSendAll_Call { + _c.Call.Return(run) + return _c +} + // NotificationsDelete provides a mock function with given fields: ctx, notifications func (_m *MockNakamaModule) NotificationsDelete(ctx context.Context, notifications []*runtime.NotificationDelete) error { ret := _m.Called(ctx, notifications) + if len(ret) == 0 { + panic("no return value specified for NotificationsDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.NotificationDelete) error); ok { r0 = rf(ctx, notifications) @@ -1651,10 +4239,219 @@ func (_m *MockNakamaModule) NotificationsDelete(ctx context.Context, notificatio return r0 } +// MockNakamaModule_NotificationsDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsDelete' +type MockNakamaModule_NotificationsDelete_Call struct { + *mock.Call +} + +// NotificationsDelete is a helper method to define mock.On call +// - ctx context.Context +// - notifications []*runtime.NotificationDelete +func (_e *MockNakamaModule_Expecter) NotificationsDelete(ctx interface{}, notifications interface{}) *MockNakamaModule_NotificationsDelete_Call { + return &MockNakamaModule_NotificationsDelete_Call{Call: _e.mock.On("NotificationsDelete", ctx, notifications)} +} + +func (_c *MockNakamaModule_NotificationsDelete_Call) Run(run func(ctx context.Context, notifications []*runtime.NotificationDelete)) *MockNakamaModule_NotificationsDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.NotificationDelete)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsDelete_Call) Return(_a0 error) *MockNakamaModule_NotificationsDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationsDelete_Call) RunAndReturn(run func(context.Context, []*runtime.NotificationDelete) error) *MockNakamaModule_NotificationsDelete_Call { + _c.Call.Return(run) + return _c +} + +// NotificationsDeleteId provides a mock function with given fields: ctx, userID, ids +func (_m *MockNakamaModule) NotificationsDeleteId(ctx context.Context, userID string, ids []string) error { + ret := _m.Called(ctx, userID, ids) + + if len(ret) == 0 { + panic("no return value specified for NotificationsDeleteId") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, []string) error); ok { + r0 = rf(ctx, userID, ids) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_NotificationsDeleteId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsDeleteId' +type MockNakamaModule_NotificationsDeleteId_Call struct { + *mock.Call +} + +// NotificationsDeleteId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - ids []string +func (_e *MockNakamaModule_Expecter) NotificationsDeleteId(ctx interface{}, userID interface{}, ids interface{}) *MockNakamaModule_NotificationsDeleteId_Call { + return &MockNakamaModule_NotificationsDeleteId_Call{Call: _e.mock.On("NotificationsDeleteId", ctx, userID, ids)} +} + +func (_c *MockNakamaModule_NotificationsDeleteId_Call) Run(run func(ctx context.Context, userID string, ids []string)) *MockNakamaModule_NotificationsDeleteId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsDeleteId_Call) Return(_a0 error) *MockNakamaModule_NotificationsDeleteId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationsDeleteId_Call) RunAndReturn(run func(context.Context, string, []string) error) *MockNakamaModule_NotificationsDeleteId_Call { + _c.Call.Return(run) + return _c +} + +// NotificationsGetId provides a mock function with given fields: ctx, userID, ids +func (_m *MockNakamaModule) NotificationsGetId(ctx context.Context, userID string, ids []string) ([]*runtime.Notification, error) { + ret := _m.Called(ctx, userID, ids) + + if len(ret) == 0 { + panic("no return value specified for NotificationsGetId") + } + + var r0 []*runtime.Notification + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, []string) ([]*runtime.Notification, error)); ok { + return rf(ctx, userID, ids) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []string) []*runtime.Notification); ok { + r0 = rf(ctx, userID, ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*runtime.Notification) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok { + r1 = rf(ctx, userID, ids) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNakamaModule_NotificationsGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsGetId' +type MockNakamaModule_NotificationsGetId_Call struct { + *mock.Call +} + +// NotificationsGetId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - ids []string +func (_e *MockNakamaModule_Expecter) NotificationsGetId(ctx interface{}, userID interface{}, ids interface{}) *MockNakamaModule_NotificationsGetId_Call { + return &MockNakamaModule_NotificationsGetId_Call{Call: _e.mock.On("NotificationsGetId", ctx, userID, ids)} +} + +func (_c *MockNakamaModule_NotificationsGetId_Call) Run(run func(ctx context.Context, userID string, ids []string)) *MockNakamaModule_NotificationsGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsGetId_Call) Return(_a0 []*runtime.Notification, _a1 error) *MockNakamaModule_NotificationsGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_NotificationsGetId_Call) RunAndReturn(run func(context.Context, string, []string) ([]*runtime.Notification, error)) *MockNakamaModule_NotificationsGetId_Call { + _c.Call.Return(run) + return _c +} + +// NotificationsList provides a mock function with given fields: ctx, userID, limit, cursor +func (_m *MockNakamaModule) NotificationsList(ctx context.Context, userID string, limit int, cursor string) ([]*api.Notification, string, error) { + ret := _m.Called(ctx, userID, limit, cursor) + + if len(ret) == 0 { + panic("no return value specified for NotificationsList") + } + + var r0 []*api.Notification + var r1 string + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, int, string) ([]*api.Notification, string, error)); ok { + return rf(ctx, userID, limit, cursor) + } + if rf, ok := ret.Get(0).(func(context.Context, string, int, string) []*api.Notification); ok { + r0 = rf(ctx, userID, limit, cursor) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.Notification) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, int, string) string); ok { + r1 = rf(ctx, userID, limit, cursor) + } else { + r1 = ret.Get(1).(string) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, int, string) error); ok { + r2 = rf(ctx, userID, limit, cursor) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockNakamaModule_NotificationsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsList' +type MockNakamaModule_NotificationsList_Call struct { + *mock.Call +} + +// NotificationsList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) NotificationsList(ctx interface{}, userID interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_NotificationsList_Call { + return &MockNakamaModule_NotificationsList_Call{Call: _e.mock.On("NotificationsList", ctx, userID, limit, cursor)} +} + +func (_c *MockNakamaModule_NotificationsList_Call) Run(run func(ctx context.Context, userID string, limit int, cursor string)) *MockNakamaModule_NotificationsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsList_Call) Return(_a0 []*api.Notification, _a1 string, _a2 error) *MockNakamaModule_NotificationsList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_NotificationsList_Call) RunAndReturn(run func(context.Context, string, int, string) ([]*api.Notification, string, error)) *MockNakamaModule_NotificationsList_Call { + _c.Call.Return(run) + return _c +} + // NotificationsSend provides a mock function with given fields: ctx, notifications func (_m *MockNakamaModule) NotificationsSend(ctx context.Context, notifications []*runtime.NotificationSend) error { ret := _m.Called(ctx, notifications) + if len(ret) == 0 { + panic("no return value specified for NotificationsSend") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.NotificationSend) error); ok { r0 = rf(ctx, notifications) @@ -1665,10 +4462,104 @@ func (_m *MockNakamaModule) NotificationsSend(ctx context.Context, notifications return r0 } +// MockNakamaModule_NotificationsSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsSend' +type MockNakamaModule_NotificationsSend_Call struct { + *mock.Call +} + +// NotificationsSend is a helper method to define mock.On call +// - ctx context.Context +// - notifications []*runtime.NotificationSend +func (_e *MockNakamaModule_Expecter) NotificationsSend(ctx interface{}, notifications interface{}) *MockNakamaModule_NotificationsSend_Call { + return &MockNakamaModule_NotificationsSend_Call{Call: _e.mock.On("NotificationsSend", ctx, notifications)} +} + +func (_c *MockNakamaModule_NotificationsSend_Call) Run(run func(ctx context.Context, notifications []*runtime.NotificationSend)) *MockNakamaModule_NotificationsSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.NotificationSend)) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsSend_Call) Return(_a0 error) *MockNakamaModule_NotificationsSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationsSend_Call) RunAndReturn(run func(context.Context, []*runtime.NotificationSend) error) *MockNakamaModule_NotificationsSend_Call { + _c.Call.Return(run) + return _c +} + +// NotificationsUpdate provides a mock function with given fields: ctx, updates +func (_m *MockNakamaModule) NotificationsUpdate(ctx context.Context, updates ...runtime.NotificationUpdate) error { + _va := make([]interface{}, len(updates)) + for _i := range updates { + _va[_i] = updates[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for NotificationsUpdate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, ...runtime.NotificationUpdate) error); ok { + r0 = rf(ctx, updates...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_NotificationsUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotificationsUpdate' +type MockNakamaModule_NotificationsUpdate_Call struct { + *mock.Call +} + +// NotificationsUpdate is a helper method to define mock.On call +// - ctx context.Context +// - updates ...runtime.NotificationUpdate +func (_e *MockNakamaModule_Expecter) NotificationsUpdate(ctx interface{}, updates ...interface{}) *MockNakamaModule_NotificationsUpdate_Call { + return &MockNakamaModule_NotificationsUpdate_Call{Call: _e.mock.On("NotificationsUpdate", + append([]interface{}{ctx}, updates...)...)} +} + +func (_c *MockNakamaModule_NotificationsUpdate_Call) Run(run func(ctx context.Context, updates ...runtime.NotificationUpdate)) *MockNakamaModule_NotificationsUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]runtime.NotificationUpdate, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(runtime.NotificationUpdate) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_NotificationsUpdate_Call) Return(_a0 error) *MockNakamaModule_NotificationsUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_NotificationsUpdate_Call) RunAndReturn(run func(context.Context, ...runtime.NotificationUpdate) error) *MockNakamaModule_NotificationsUpdate_Call { + _c.Call.Return(run) + return _c +} + // PurchaseGetByTransactionId provides a mock function with given fields: ctx, transactionID func (_m *MockNakamaModule) PurchaseGetByTransactionId(ctx context.Context, transactionID string) (*api.ValidatedPurchase, error) { ret := _m.Called(ctx, transactionID) + if len(ret) == 0 { + panic("no return value specified for PurchaseGetByTransactionId") + } + var r0 *api.ValidatedPurchase var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*api.ValidatedPurchase, error)); ok { @@ -1691,6 +4582,35 @@ func (_m *MockNakamaModule) PurchaseGetByTransactionId(ctx context.Context, tran return r0, r1 } +// MockNakamaModule_PurchaseGetByTransactionId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseGetByTransactionId' +type MockNakamaModule_PurchaseGetByTransactionId_Call struct { + *mock.Call +} + +// PurchaseGetByTransactionId is a helper method to define mock.On call +// - ctx context.Context +// - transactionID string +func (_e *MockNakamaModule_Expecter) PurchaseGetByTransactionId(ctx interface{}, transactionID interface{}) *MockNakamaModule_PurchaseGetByTransactionId_Call { + return &MockNakamaModule_PurchaseGetByTransactionId_Call{Call: _e.mock.On("PurchaseGetByTransactionId", ctx, transactionID)} +} + +func (_c *MockNakamaModule_PurchaseGetByTransactionId_Call) Run(run func(ctx context.Context, transactionID string)) *MockNakamaModule_PurchaseGetByTransactionId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_PurchaseGetByTransactionId_Call) Return(_a0 *api.ValidatedPurchase, _a1 error) *MockNakamaModule_PurchaseGetByTransactionId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchaseGetByTransactionId_Call) RunAndReturn(run func(context.Context, string) (*api.ValidatedPurchase, error)) *MockNakamaModule_PurchaseGetByTransactionId_Call { + _c.Call.Return(run) + return _c +} + // PurchaseValidateApple provides a mock function with given fields: ctx, userID, receipt, persist, passwordOverride func (_m *MockNakamaModule) PurchaseValidateApple(ctx context.Context, userID string, receipt string, persist bool, passwordOverride ...string) (*api.ValidatePurchaseResponse, error) { _va := make([]interface{}, len(passwordOverride)) @@ -1702,6 +4622,10 @@ func (_m *MockNakamaModule) PurchaseValidateApple(ctx context.Context, userID st _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for PurchaseValidateApple") + } + var r0 *api.ValidatePurchaseResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, ...string) (*api.ValidatePurchaseResponse, error)); ok { @@ -1724,10 +4648,53 @@ func (_m *MockNakamaModule) PurchaseValidateApple(ctx context.Context, userID st return r0, r1 } +// MockNakamaModule_PurchaseValidateApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseValidateApple' +type MockNakamaModule_PurchaseValidateApple_Call struct { + *mock.Call +} + +// PurchaseValidateApple is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - receipt string +// - persist bool +// - passwordOverride ...string +func (_e *MockNakamaModule_Expecter) PurchaseValidateApple(ctx interface{}, userID interface{}, receipt interface{}, persist interface{}, passwordOverride ...interface{}) *MockNakamaModule_PurchaseValidateApple_Call { + return &MockNakamaModule_PurchaseValidateApple_Call{Call: _e.mock.On("PurchaseValidateApple", + append([]interface{}{ctx, userID, receipt, persist}, passwordOverride...)...)} +} + +func (_c *MockNakamaModule_PurchaseValidateApple_Call) Run(run func(ctx context.Context, userID string, receipt string, persist bool, passwordOverride ...string)) *MockNakamaModule_PurchaseValidateApple_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateApple_Call) Return(_a0 *api.ValidatePurchaseResponse, _a1 error) *MockNakamaModule_PurchaseValidateApple_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateApple_Call) RunAndReturn(run func(context.Context, string, string, bool, ...string) (*api.ValidatePurchaseResponse, error)) *MockNakamaModule_PurchaseValidateApple_Call { + _c.Call.Return(run) + return _c +} + // PurchaseValidateFacebookInstant provides a mock function with given fields: ctx, userID, signedRequest, persist func (_m *MockNakamaModule) PurchaseValidateFacebookInstant(ctx context.Context, userID string, signedRequest string, persist bool) (*api.ValidatePurchaseResponse, error) { ret := _m.Called(ctx, userID, signedRequest, persist) + if len(ret) == 0 { + panic("no return value specified for PurchaseValidateFacebookInstant") + } + var r0 *api.ValidatePurchaseResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, bool) (*api.ValidatePurchaseResponse, error)); ok { @@ -1750,6 +4717,37 @@ func (_m *MockNakamaModule) PurchaseValidateFacebookInstant(ctx context.Context, return r0, r1 } +// MockNakamaModule_PurchaseValidateFacebookInstant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseValidateFacebookInstant' +type MockNakamaModule_PurchaseValidateFacebookInstant_Call struct { + *mock.Call +} + +// PurchaseValidateFacebookInstant is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - signedRequest string +// - persist bool +func (_e *MockNakamaModule_Expecter) PurchaseValidateFacebookInstant(ctx interface{}, userID interface{}, signedRequest interface{}, persist interface{}) *MockNakamaModule_PurchaseValidateFacebookInstant_Call { + return &MockNakamaModule_PurchaseValidateFacebookInstant_Call{Call: _e.mock.On("PurchaseValidateFacebookInstant", ctx, userID, signedRequest, persist)} +} + +func (_c *MockNakamaModule_PurchaseValidateFacebookInstant_Call) Run(run func(ctx context.Context, userID string, signedRequest string, persist bool)) *MockNakamaModule_PurchaseValidateFacebookInstant_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateFacebookInstant_Call) Return(_a0 *api.ValidatePurchaseResponse, _a1 error) *MockNakamaModule_PurchaseValidateFacebookInstant_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateFacebookInstant_Call) RunAndReturn(run func(context.Context, string, string, bool) (*api.ValidatePurchaseResponse, error)) *MockNakamaModule_PurchaseValidateFacebookInstant_Call { + _c.Call.Return(run) + return _c +} + // PurchaseValidateGoogle provides a mock function with given fields: ctx, userID, receipt, persist, overrides func (_m *MockNakamaModule) PurchaseValidateGoogle(ctx context.Context, userID string, receipt string, persist bool, overrides ...struct { ClientEmail string @@ -1764,6 +4762,10 @@ func (_m *MockNakamaModule) PurchaseValidateGoogle(ctx context.Context, userID s _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for PurchaseValidateGoogle") + } + var r0 *api.ValidatePurchaseResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, ...struct { @@ -1795,10 +4797,65 @@ func (_m *MockNakamaModule) PurchaseValidateGoogle(ctx context.Context, userID s return r0, r1 } +// MockNakamaModule_PurchaseValidateGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseValidateGoogle' +type MockNakamaModule_PurchaseValidateGoogle_Call struct { + *mock.Call +} + +// PurchaseValidateGoogle is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - receipt string +// - persist bool +// - overrides ...struct{ClientEmail string;PrivateKey string} +func (_e *MockNakamaModule_Expecter) PurchaseValidateGoogle(ctx interface{}, userID interface{}, receipt interface{}, persist interface{}, overrides ...interface{}) *MockNakamaModule_PurchaseValidateGoogle_Call { + return &MockNakamaModule_PurchaseValidateGoogle_Call{Call: _e.mock.On("PurchaseValidateGoogle", + append([]interface{}{ctx, userID, receipt, persist}, overrides...)...)} +} + +func (_c *MockNakamaModule_PurchaseValidateGoogle_Call) Run(run func(ctx context.Context, userID string, receipt string, persist bool, overrides ...struct { + ClientEmail string + PrivateKey string +})) *MockNakamaModule_PurchaseValidateGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]struct { + ClientEmail string + PrivateKey string + }, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(struct { + ClientEmail string + PrivateKey string + }) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateGoogle_Call) Return(_a0 *api.ValidatePurchaseResponse, _a1 error) *MockNakamaModule_PurchaseValidateGoogle_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateGoogle_Call) RunAndReturn(run func(context.Context, string, string, bool, ...struct { + ClientEmail string + PrivateKey string +}) (*api.ValidatePurchaseResponse, error)) *MockNakamaModule_PurchaseValidateGoogle_Call { + _c.Call.Return(run) + return _c +} + // PurchaseValidateHuawei provides a mock function with given fields: ctx, userID, signature, inAppPurchaseData, persist func (_m *MockNakamaModule) PurchaseValidateHuawei(ctx context.Context, userID string, signature string, inAppPurchaseData string, persist bool) (*api.ValidatePurchaseResponse, error) { ret := _m.Called(ctx, userID, signature, inAppPurchaseData, persist) + if len(ret) == 0 { + panic("no return value specified for PurchaseValidateHuawei") + } + var r0 *api.ValidatePurchaseResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, bool) (*api.ValidatePurchaseResponse, error)); ok { @@ -1821,10 +4878,46 @@ func (_m *MockNakamaModule) PurchaseValidateHuawei(ctx context.Context, userID s return r0, r1 } +// MockNakamaModule_PurchaseValidateHuawei_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseValidateHuawei' +type MockNakamaModule_PurchaseValidateHuawei_Call struct { + *mock.Call +} + +// PurchaseValidateHuawei is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - signature string +// - inAppPurchaseData string +// - persist bool +func (_e *MockNakamaModule_Expecter) PurchaseValidateHuawei(ctx interface{}, userID interface{}, signature interface{}, inAppPurchaseData interface{}, persist interface{}) *MockNakamaModule_PurchaseValidateHuawei_Call { + return &MockNakamaModule_PurchaseValidateHuawei_Call{Call: _e.mock.On("PurchaseValidateHuawei", ctx, userID, signature, inAppPurchaseData, persist)} +} + +func (_c *MockNakamaModule_PurchaseValidateHuawei_Call) Run(run func(ctx context.Context, userID string, signature string, inAppPurchaseData string, persist bool)) *MockNakamaModule_PurchaseValidateHuawei_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateHuawei_Call) Return(_a0 *api.ValidatePurchaseResponse, _a1 error) *MockNakamaModule_PurchaseValidateHuawei_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchaseValidateHuawei_Call) RunAndReturn(run func(context.Context, string, string, string, bool) (*api.ValidatePurchaseResponse, error)) *MockNakamaModule_PurchaseValidateHuawei_Call { + _c.Call.Return(run) + return _c +} + // PurchasesList provides a mock function with given fields: ctx, userID, limit, cursor func (_m *MockNakamaModule) PurchasesList(ctx context.Context, userID string, limit int, cursor string) (*api.PurchaseList, error) { ret := _m.Called(ctx, userID, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for PurchasesList") + } + var r0 *api.PurchaseList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, int, string) (*api.PurchaseList, error)); ok { @@ -1847,10 +4940,45 @@ func (_m *MockNakamaModule) PurchasesList(ctx context.Context, userID string, li return r0, r1 } +// MockNakamaModule_PurchasesList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchasesList' +type MockNakamaModule_PurchasesList_Call struct { + *mock.Call +} + +// PurchasesList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) PurchasesList(ctx interface{}, userID interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_PurchasesList_Call { + return &MockNakamaModule_PurchasesList_Call{Call: _e.mock.On("PurchasesList", ctx, userID, limit, cursor)} +} + +func (_c *MockNakamaModule_PurchasesList_Call) Run(run func(ctx context.Context, userID string, limit int, cursor string)) *MockNakamaModule_PurchasesList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_PurchasesList_Call) Return(_a0 *api.PurchaseList, _a1 error) *MockNakamaModule_PurchasesList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_PurchasesList_Call) RunAndReturn(run func(context.Context, string, int, string) (*api.PurchaseList, error)) *MockNakamaModule_PurchasesList_Call { + _c.Call.Return(run) + return _c +} + // ReadFile provides a mock function with given fields: path func (_m *MockNakamaModule) ReadFile(path string) (*os.File, error) { ret := _m.Called(path) + if len(ret) == 0 { + panic("no return value specified for ReadFile") + } + var r0 *os.File var r1 error if rf, ok := ret.Get(0).(func(string) (*os.File, error)); ok { @@ -1873,6 +5001,34 @@ func (_m *MockNakamaModule) ReadFile(path string) (*os.File, error) { return r0, r1 } +// MockNakamaModule_ReadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadFile' +type MockNakamaModule_ReadFile_Call struct { + *mock.Call +} + +// ReadFile is a helper method to define mock.On call +// - path string +func (_e *MockNakamaModule_Expecter) ReadFile(path interface{}) *MockNakamaModule_ReadFile_Call { + return &MockNakamaModule_ReadFile_Call{Call: _e.mock.On("ReadFile", path)} +} + +func (_c *MockNakamaModule_ReadFile_Call) Run(run func(path string)) *MockNakamaModule_ReadFile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_ReadFile_Call) Return(_a0 *os.File, _a1 error) *MockNakamaModule_ReadFile_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_ReadFile_Call) RunAndReturn(run func(string) (*os.File, error)) *MockNakamaModule_ReadFile_Call { + _c.Call.Return(run) + return _c +} + // SessionDisconnect provides a mock function with given fields: ctx, sessionID, reason func (_m *MockNakamaModule) SessionDisconnect(ctx context.Context, sessionID string, reason ...runtime.PresenceReason) error { _va := make([]interface{}, len(reason)) @@ -1884,6 +5040,10 @@ func (_m *MockNakamaModule) SessionDisconnect(ctx context.Context, sessionID str _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for SessionDisconnect") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, ...runtime.PresenceReason) error); ok { r0 = rf(ctx, sessionID, reason...) @@ -1894,10 +5054,51 @@ func (_m *MockNakamaModule) SessionDisconnect(ctx context.Context, sessionID str return r0 } +// MockNakamaModule_SessionDisconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SessionDisconnect' +type MockNakamaModule_SessionDisconnect_Call struct { + *mock.Call +} + +// SessionDisconnect is a helper method to define mock.On call +// - ctx context.Context +// - sessionID string +// - reason ...runtime.PresenceReason +func (_e *MockNakamaModule_Expecter) SessionDisconnect(ctx interface{}, sessionID interface{}, reason ...interface{}) *MockNakamaModule_SessionDisconnect_Call { + return &MockNakamaModule_SessionDisconnect_Call{Call: _e.mock.On("SessionDisconnect", + append([]interface{}{ctx, sessionID}, reason...)...)} +} + +func (_c *MockNakamaModule_SessionDisconnect_Call) Run(run func(ctx context.Context, sessionID string, reason ...runtime.PresenceReason)) *MockNakamaModule_SessionDisconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]runtime.PresenceReason, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(runtime.PresenceReason) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_SessionDisconnect_Call) Return(_a0 error) *MockNakamaModule_SessionDisconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_SessionDisconnect_Call) RunAndReturn(run func(context.Context, string, ...runtime.PresenceReason) error) *MockNakamaModule_SessionDisconnect_Call { + _c.Call.Return(run) + return _c +} + // SessionLogout provides a mock function with given fields: userID, token, refreshToken func (_m *MockNakamaModule) SessionLogout(userID string, token string, refreshToken string) error { ret := _m.Called(userID, token, refreshToken) + if len(ret) == 0 { + panic("no return value specified for SessionLogout") + } + var r0 error if rf, ok := ret.Get(0).(func(string, string, string) error); ok { r0 = rf(userID, token, refreshToken) @@ -1908,10 +5109,138 @@ func (_m *MockNakamaModule) SessionLogout(userID string, token string, refreshTo return r0 } +// MockNakamaModule_SessionLogout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SessionLogout' +type MockNakamaModule_SessionLogout_Call struct { + *mock.Call +} + +// SessionLogout is a helper method to define mock.On call +// - userID string +// - token string +// - refreshToken string +func (_e *MockNakamaModule_Expecter) SessionLogout(userID interface{}, token interface{}, refreshToken interface{}) *MockNakamaModule_SessionLogout_Call { + return &MockNakamaModule_SessionLogout_Call{Call: _e.mock.On("SessionLogout", userID, token, refreshToken)} +} + +func (_c *MockNakamaModule_SessionLogout_Call) Run(run func(userID string, token string, refreshToken string)) *MockNakamaModule_SessionLogout_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_SessionLogout_Call) Return(_a0 error) *MockNakamaModule_SessionLogout_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_SessionLogout_Call) RunAndReturn(run func(string, string, string) error) *MockNakamaModule_SessionLogout_Call { + _c.Call.Return(run) + return _c +} + +// StatusFollow provides a mock function with given fields: sessionID, userIDs +func (_m *MockNakamaModule) StatusFollow(sessionID string, userIDs []string) error { + ret := _m.Called(sessionID, userIDs) + + if len(ret) == 0 { + panic("no return value specified for StatusFollow") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, []string) error); ok { + r0 = rf(sessionID, userIDs) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_StatusFollow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatusFollow' +type MockNakamaModule_StatusFollow_Call struct { + *mock.Call +} + +// StatusFollow is a helper method to define mock.On call +// - sessionID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) StatusFollow(sessionID interface{}, userIDs interface{}) *MockNakamaModule_StatusFollow_Call { + return &MockNakamaModule_StatusFollow_Call{Call: _e.mock.On("StatusFollow", sessionID, userIDs)} +} + +func (_c *MockNakamaModule_StatusFollow_Call) Run(run func(sessionID string, userIDs []string)) *MockNakamaModule_StatusFollow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_StatusFollow_Call) Return(_a0 error) *MockNakamaModule_StatusFollow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StatusFollow_Call) RunAndReturn(run func(string, []string) error) *MockNakamaModule_StatusFollow_Call { + _c.Call.Return(run) + return _c +} + +// StatusUnfollow provides a mock function with given fields: sessionID, userIDs +func (_m *MockNakamaModule) StatusUnfollow(sessionID string, userIDs []string) error { + ret := _m.Called(sessionID, userIDs) + + if len(ret) == 0 { + panic("no return value specified for StatusUnfollow") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, []string) error); ok { + r0 = rf(sessionID, userIDs) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_StatusUnfollow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatusUnfollow' +type MockNakamaModule_StatusUnfollow_Call struct { + *mock.Call +} + +// StatusUnfollow is a helper method to define mock.On call +// - sessionID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) StatusUnfollow(sessionID interface{}, userIDs interface{}) *MockNakamaModule_StatusUnfollow_Call { + return &MockNakamaModule_StatusUnfollow_Call{Call: _e.mock.On("StatusUnfollow", sessionID, userIDs)} +} + +func (_c *MockNakamaModule_StatusUnfollow_Call) Run(run func(sessionID string, userIDs []string)) *MockNakamaModule_StatusUnfollow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_StatusUnfollow_Call) Return(_a0 error) *MockNakamaModule_StatusUnfollow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StatusUnfollow_Call) RunAndReturn(run func(string, []string) error) *MockNakamaModule_StatusUnfollow_Call { + _c.Call.Return(run) + return _c +} + // StorageDelete provides a mock function with given fields: ctx, deletes func (_m *MockNakamaModule) StorageDelete(ctx context.Context, deletes []*runtime.StorageDelete) error { ret := _m.Called(ctx, deletes) + if len(ret) == 0 { + panic("no return value specified for StorageDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.StorageDelete) error); ok { r0 = rf(ctx, deletes) @@ -1922,36 +5251,114 @@ func (_m *MockNakamaModule) StorageDelete(ctx context.Context, deletes []*runtim return r0 } -// StorageIndexList provides a mock function with given fields: ctx, callerID, indexName, query, limit, order -func (_m *MockNakamaModule) StorageIndexList(ctx context.Context, callerID string, indexName string, query string, limit int, order []string) (*api.StorageObjects, error) { - ret := _m.Called(ctx, callerID, indexName, query, limit, order) +// MockNakamaModule_StorageDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageDelete' +type MockNakamaModule_StorageDelete_Call struct { + *mock.Call +} + +// StorageDelete is a helper method to define mock.On call +// - ctx context.Context +// - deletes []*runtime.StorageDelete +func (_e *MockNakamaModule_Expecter) StorageDelete(ctx interface{}, deletes interface{}) *MockNakamaModule_StorageDelete_Call { + return &MockNakamaModule_StorageDelete_Call{Call: _e.mock.On("StorageDelete", ctx, deletes)} +} + +func (_c *MockNakamaModule_StorageDelete_Call) Run(run func(ctx context.Context, deletes []*runtime.StorageDelete)) *MockNakamaModule_StorageDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.StorageDelete)) + }) + return _c +} + +func (_c *MockNakamaModule_StorageDelete_Call) Return(_a0 error) *MockNakamaModule_StorageDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StorageDelete_Call) RunAndReturn(run func(context.Context, []*runtime.StorageDelete) error) *MockNakamaModule_StorageDelete_Call { + _c.Call.Return(run) + return _c +} + +// StorageIndexList provides a mock function with given fields: ctx, callerID, indexName, query, limit, order, cursor +func (_m *MockNakamaModule) StorageIndexList(ctx context.Context, callerID string, indexName string, query string, limit int, order []string, cursor string) (*api.StorageObjects, string, error) { + ret := _m.Called(ctx, callerID, indexName, query, limit, order, cursor) + + if len(ret) == 0 { + panic("no return value specified for StorageIndexList") + } var r0 *api.StorageObjects - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int, []string) (*api.StorageObjects, error)); ok { - return rf(ctx, callerID, indexName, query, limit, order) + var r1 string + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int, []string, string) (*api.StorageObjects, string, error)); ok { + return rf(ctx, callerID, indexName, query, limit, order, cursor) } - if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int, []string) *api.StorageObjects); ok { - r0 = rf(ctx, callerID, indexName, query, limit, order) + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int, []string, string) *api.StorageObjects); ok { + r0 = rf(ctx, callerID, indexName, query, limit, order, cursor) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*api.StorageObjects) } } - if rf, ok := ret.Get(1).(func(context.Context, string, string, string, int, []string) error); ok { - r1 = rf(ctx, callerID, indexName, query, limit, order) + if rf, ok := ret.Get(1).(func(context.Context, string, string, string, int, []string, string) string); ok { + r1 = rf(ctx, callerID, indexName, query, limit, order, cursor) } else { - r1 = ret.Error(1) + r1 = ret.Get(1).(string) } - return r0, r1 + if rf, ok := ret.Get(2).(func(context.Context, string, string, string, int, []string, string) error); ok { + r2 = rf(ctx, callerID, indexName, query, limit, order, cursor) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockNakamaModule_StorageIndexList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageIndexList' +type MockNakamaModule_StorageIndexList_Call struct { + *mock.Call +} + +// StorageIndexList is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - indexName string +// - query string +// - limit int +// - order []string +// - cursor string +func (_e *MockNakamaModule_Expecter) StorageIndexList(ctx interface{}, callerID interface{}, indexName interface{}, query interface{}, limit interface{}, order interface{}, cursor interface{}) *MockNakamaModule_StorageIndexList_Call { + return &MockNakamaModule_StorageIndexList_Call{Call: _e.mock.On("StorageIndexList", ctx, callerID, indexName, query, limit, order, cursor)} +} + +func (_c *MockNakamaModule_StorageIndexList_Call) Run(run func(ctx context.Context, callerID string, indexName string, query string, limit int, order []string, cursor string)) *MockNakamaModule_StorageIndexList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int), args[5].([]string), args[6].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StorageIndexList_Call) Return(_a0 *api.StorageObjects, _a1 string, _a2 error) *MockNakamaModule_StorageIndexList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_StorageIndexList_Call) RunAndReturn(run func(context.Context, string, string, string, int, []string, string) (*api.StorageObjects, string, error)) *MockNakamaModule_StorageIndexList_Call { + _c.Call.Return(run) + return _c } // StorageList provides a mock function with given fields: ctx, callerID, userID, collection, limit, cursor func (_m *MockNakamaModule) StorageList(ctx context.Context, callerID string, userID string, collection string, limit int, cursor string) ([]*api.StorageObject, string, error) { ret := _m.Called(ctx, callerID, userID, collection, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for StorageList") + } + var r0 []*api.StorageObject var r1 string var r2 error @@ -1981,10 +5388,47 @@ func (_m *MockNakamaModule) StorageList(ctx context.Context, callerID string, us return r0, r1, r2 } +// MockNakamaModule_StorageList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageList' +type MockNakamaModule_StorageList_Call struct { + *mock.Call +} + +// StorageList is a helper method to define mock.On call +// - ctx context.Context +// - callerID string +// - userID string +// - collection string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) StorageList(ctx interface{}, callerID interface{}, userID interface{}, collection interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_StorageList_Call { + return &MockNakamaModule_StorageList_Call{Call: _e.mock.On("StorageList", ctx, callerID, userID, collection, limit, cursor)} +} + +func (_c *MockNakamaModule_StorageList_Call) Run(run func(ctx context.Context, callerID string, userID string, collection string, limit int, cursor string)) *MockNakamaModule_StorageList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int), args[5].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StorageList_Call) Return(_a0 []*api.StorageObject, _a1 string, _a2 error) *MockNakamaModule_StorageList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_StorageList_Call) RunAndReturn(run func(context.Context, string, string, string, int, string) ([]*api.StorageObject, string, error)) *MockNakamaModule_StorageList_Call { + _c.Call.Return(run) + return _c +} + // StorageRead provides a mock function with given fields: ctx, reads func (_m *MockNakamaModule) StorageRead(ctx context.Context, reads []*runtime.StorageRead) ([]*api.StorageObject, error) { ret := _m.Called(ctx, reads) + if len(ret) == 0 { + panic("no return value specified for StorageRead") + } + var r0 []*api.StorageObject var r1 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.StorageRead) ([]*api.StorageObject, error)); ok { @@ -2007,10 +5451,43 @@ func (_m *MockNakamaModule) StorageRead(ctx context.Context, reads []*runtime.St return r0, r1 } +// MockNakamaModule_StorageRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageRead' +type MockNakamaModule_StorageRead_Call struct { + *mock.Call +} + +// StorageRead is a helper method to define mock.On call +// - ctx context.Context +// - reads []*runtime.StorageRead +func (_e *MockNakamaModule_Expecter) StorageRead(ctx interface{}, reads interface{}) *MockNakamaModule_StorageRead_Call { + return &MockNakamaModule_StorageRead_Call{Call: _e.mock.On("StorageRead", ctx, reads)} +} + +func (_c *MockNakamaModule_StorageRead_Call) Run(run func(ctx context.Context, reads []*runtime.StorageRead)) *MockNakamaModule_StorageRead_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.StorageRead)) + }) + return _c +} + +func (_c *MockNakamaModule_StorageRead_Call) Return(_a0 []*api.StorageObject, _a1 error) *MockNakamaModule_StorageRead_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StorageRead_Call) RunAndReturn(run func(context.Context, []*runtime.StorageRead) ([]*api.StorageObject, error)) *MockNakamaModule_StorageRead_Call { + _c.Call.Return(run) + return _c +} + // StorageWrite provides a mock function with given fields: ctx, writes func (_m *MockNakamaModule) StorageWrite(ctx context.Context, writes []*runtime.StorageWrite) ([]*api.StorageObjectAck, error) { ret := _m.Called(ctx, writes) + if len(ret) == 0 { + panic("no return value specified for StorageWrite") + } + var r0 []*api.StorageObjectAck var r1 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.StorageWrite) ([]*api.StorageObjectAck, error)); ok { @@ -2033,10 +5510,43 @@ func (_m *MockNakamaModule) StorageWrite(ctx context.Context, writes []*runtime. return r0, r1 } +// MockNakamaModule_StorageWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageWrite' +type MockNakamaModule_StorageWrite_Call struct { + *mock.Call +} + +// StorageWrite is a helper method to define mock.On call +// - ctx context.Context +// - writes []*runtime.StorageWrite +func (_e *MockNakamaModule_Expecter) StorageWrite(ctx interface{}, writes interface{}) *MockNakamaModule_StorageWrite_Call { + return &MockNakamaModule_StorageWrite_Call{Call: _e.mock.On("StorageWrite", ctx, writes)} +} + +func (_c *MockNakamaModule_StorageWrite_Call) Run(run func(ctx context.Context, writes []*runtime.StorageWrite)) *MockNakamaModule_StorageWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.StorageWrite)) + }) + return _c +} + +func (_c *MockNakamaModule_StorageWrite_Call) Return(_a0 []*api.StorageObjectAck, _a1 error) *MockNakamaModule_StorageWrite_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StorageWrite_Call) RunAndReturn(run func(context.Context, []*runtime.StorageWrite) ([]*api.StorageObjectAck, error)) *MockNakamaModule_StorageWrite_Call { + _c.Call.Return(run) + return _c +} + // StreamClose provides a mock function with given fields: mode, subject, subcontext, label func (_m *MockNakamaModule) StreamClose(mode uint8, subject string, subcontext string, label string) error { ret := _m.Called(mode, subject, subcontext, label) + if len(ret) == 0 { + panic("no return value specified for StreamClose") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string) error); ok { r0 = rf(mode, subject, subcontext, label) @@ -2047,10 +5557,45 @@ func (_m *MockNakamaModule) StreamClose(mode uint8, subject string, subcontext s return r0 } +// MockNakamaModule_StreamClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamClose' +type MockNakamaModule_StreamClose_Call struct { + *mock.Call +} + +// StreamClose is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +func (_e *MockNakamaModule_Expecter) StreamClose(mode interface{}, subject interface{}, subcontext interface{}, label interface{}) *MockNakamaModule_StreamClose_Call { + return &MockNakamaModule_StreamClose_Call{Call: _e.mock.On("StreamClose", mode, subject, subcontext, label)} +} + +func (_c *MockNakamaModule_StreamClose_Call) Run(run func(mode uint8, subject string, subcontext string, label string)) *MockNakamaModule_StreamClose_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamClose_Call) Return(_a0 error) *MockNakamaModule_StreamClose_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamClose_Call) RunAndReturn(run func(uint8, string, string, string) error) *MockNakamaModule_StreamClose_Call { + _c.Call.Return(run) + return _c +} + // StreamCount provides a mock function with given fields: mode, subject, subcontext, label func (_m *MockNakamaModule) StreamCount(mode uint8, subject string, subcontext string, label string) (int, error) { ret := _m.Called(mode, subject, subcontext, label) + if len(ret) == 0 { + panic("no return value specified for StreamCount") + } + var r0 int var r1 error if rf, ok := ret.Get(0).(func(uint8, string, string, string) (int, error)); ok { @@ -2071,10 +5616,45 @@ func (_m *MockNakamaModule) StreamCount(mode uint8, subject string, subcontext s return r0, r1 } +// MockNakamaModule_StreamCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamCount' +type MockNakamaModule_StreamCount_Call struct { + *mock.Call +} + +// StreamCount is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +func (_e *MockNakamaModule_Expecter) StreamCount(mode interface{}, subject interface{}, subcontext interface{}, label interface{}) *MockNakamaModule_StreamCount_Call { + return &MockNakamaModule_StreamCount_Call{Call: _e.mock.On("StreamCount", mode, subject, subcontext, label)} +} + +func (_c *MockNakamaModule_StreamCount_Call) Run(run func(mode uint8, subject string, subcontext string, label string)) *MockNakamaModule_StreamCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamCount_Call) Return(_a0 int, _a1 error) *MockNakamaModule_StreamCount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StreamCount_Call) RunAndReturn(run func(uint8, string, string, string) (int, error)) *MockNakamaModule_StreamCount_Call { + _c.Call.Return(run) + return _c +} + // StreamSend provides a mock function with given fields: mode, subject, subcontext, label, data, presences, reliable func (_m *MockNakamaModule) StreamSend(mode uint8, subject string, subcontext string, label string, data string, presences []runtime.Presence, reliable bool) error { ret := _m.Called(mode, subject, subcontext, label, data, presences, reliable) + if len(ret) == 0 { + panic("no return value specified for StreamSend") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, string, []runtime.Presence, bool) error); ok { r0 = rf(mode, subject, subcontext, label, data, presences, reliable) @@ -2085,10 +5665,48 @@ func (_m *MockNakamaModule) StreamSend(mode uint8, subject string, subcontext st return r0 } +// MockNakamaModule_StreamSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamSend' +type MockNakamaModule_StreamSend_Call struct { + *mock.Call +} + +// StreamSend is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - data string +// - presences []runtime.Presence +// - reliable bool +func (_e *MockNakamaModule_Expecter) StreamSend(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, data interface{}, presences interface{}, reliable interface{}) *MockNakamaModule_StreamSend_Call { + return &MockNakamaModule_StreamSend_Call{Call: _e.mock.On("StreamSend", mode, subject, subcontext, label, data, presences, reliable)} +} + +func (_c *MockNakamaModule_StreamSend_Call) Run(run func(mode uint8, subject string, subcontext string, label string, data string, presences []runtime.Presence, reliable bool)) *MockNakamaModule_StreamSend_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].([]runtime.Presence), args[6].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamSend_Call) Return(_a0 error) *MockNakamaModule_StreamSend_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamSend_Call) RunAndReturn(run func(uint8, string, string, string, string, []runtime.Presence, bool) error) *MockNakamaModule_StreamSend_Call { + _c.Call.Return(run) + return _c +} + // StreamSendRaw provides a mock function with given fields: mode, subject, subcontext, label, msg, presences, reliable func (_m *MockNakamaModule) StreamSendRaw(mode uint8, subject string, subcontext string, label string, msg *rtapi.Envelope, presences []runtime.Presence, reliable bool) error { ret := _m.Called(mode, subject, subcontext, label, msg, presences, reliable) + if len(ret) == 0 { + panic("no return value specified for StreamSendRaw") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, *rtapi.Envelope, []runtime.Presence, bool) error); ok { r0 = rf(mode, subject, subcontext, label, msg, presences, reliable) @@ -2099,10 +5717,48 @@ func (_m *MockNakamaModule) StreamSendRaw(mode uint8, subject string, subcontext return r0 } +// MockNakamaModule_StreamSendRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamSendRaw' +type MockNakamaModule_StreamSendRaw_Call struct { + *mock.Call +} + +// StreamSendRaw is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - msg *rtapi.Envelope +// - presences []runtime.Presence +// - reliable bool +func (_e *MockNakamaModule_Expecter) StreamSendRaw(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, msg interface{}, presences interface{}, reliable interface{}) *MockNakamaModule_StreamSendRaw_Call { + return &MockNakamaModule_StreamSendRaw_Call{Call: _e.mock.On("StreamSendRaw", mode, subject, subcontext, label, msg, presences, reliable)} +} + +func (_c *MockNakamaModule_StreamSendRaw_Call) Run(run func(mode uint8, subject string, subcontext string, label string, msg *rtapi.Envelope, presences []runtime.Presence, reliable bool)) *MockNakamaModule_StreamSendRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(*rtapi.Envelope), args[5].([]runtime.Presence), args[6].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamSendRaw_Call) Return(_a0 error) *MockNakamaModule_StreamSendRaw_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamSendRaw_Call) RunAndReturn(run func(uint8, string, string, string, *rtapi.Envelope, []runtime.Presence, bool) error) *MockNakamaModule_StreamSendRaw_Call { + _c.Call.Return(run) + return _c +} + // StreamUserGet provides a mock function with given fields: mode, subject, subcontext, label, userID, sessionID func (_m *MockNakamaModule) StreamUserGet(mode uint8, subject string, subcontext string, label string, userID string, sessionID string) (runtime.PresenceMeta, error) { ret := _m.Called(mode, subject, subcontext, label, userID, sessionID) + if len(ret) == 0 { + panic("no return value specified for StreamUserGet") + } + var r0 runtime.PresenceMeta var r1 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, string, string) (runtime.PresenceMeta, error)); ok { @@ -2125,10 +5781,47 @@ func (_m *MockNakamaModule) StreamUserGet(mode uint8, subject string, subcontext return r0, r1 } +// MockNakamaModule_StreamUserGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserGet' +type MockNakamaModule_StreamUserGet_Call struct { + *mock.Call +} + +// StreamUserGet is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - userID string +// - sessionID string +func (_e *MockNakamaModule_Expecter) StreamUserGet(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, userID interface{}, sessionID interface{}) *MockNakamaModule_StreamUserGet_Call { + return &MockNakamaModule_StreamUserGet_Call{Call: _e.mock.On("StreamUserGet", mode, subject, subcontext, label, userID, sessionID)} +} + +func (_c *MockNakamaModule_StreamUserGet_Call) Run(run func(mode uint8, subject string, subcontext string, label string, userID string, sessionID string)) *MockNakamaModule_StreamUserGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserGet_Call) Return(_a0 runtime.PresenceMeta, _a1 error) *MockNakamaModule_StreamUserGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StreamUserGet_Call) RunAndReturn(run func(uint8, string, string, string, string, string) (runtime.PresenceMeta, error)) *MockNakamaModule_StreamUserGet_Call { + _c.Call.Return(run) + return _c +} + // StreamUserJoin provides a mock function with given fields: mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status func (_m *MockNakamaModule) StreamUserJoin(mode uint8, subject string, subcontext string, label string, userID string, sessionID string, hidden bool, persistence bool, status string) (bool, error) { ret := _m.Called(mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status) + if len(ret) == 0 { + panic("no return value specified for StreamUserJoin") + } + var r0 bool var r1 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, string, string, bool, bool, string) (bool, error)); ok { @@ -2149,10 +5842,50 @@ func (_m *MockNakamaModule) StreamUserJoin(mode uint8, subject string, subcontex return r0, r1 } +// MockNakamaModule_StreamUserJoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserJoin' +type MockNakamaModule_StreamUserJoin_Call struct { + *mock.Call +} + +// StreamUserJoin is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - userID string +// - sessionID string +// - hidden bool +// - persistence bool +// - status string +func (_e *MockNakamaModule_Expecter) StreamUserJoin(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, userID interface{}, sessionID interface{}, hidden interface{}, persistence interface{}, status interface{}) *MockNakamaModule_StreamUserJoin_Call { + return &MockNakamaModule_StreamUserJoin_Call{Call: _e.mock.On("StreamUserJoin", mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status)} +} + +func (_c *MockNakamaModule_StreamUserJoin_Call) Run(run func(mode uint8, subject string, subcontext string, label string, userID string, sessionID string, hidden bool, persistence bool, status string)) *MockNakamaModule_StreamUserJoin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(bool), args[7].(bool), args[8].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserJoin_Call) Return(_a0 bool, _a1 error) *MockNakamaModule_StreamUserJoin_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StreamUserJoin_Call) RunAndReturn(run func(uint8, string, string, string, string, string, bool, bool, string) (bool, error)) *MockNakamaModule_StreamUserJoin_Call { + _c.Call.Return(run) + return _c +} + // StreamUserKick provides a mock function with given fields: mode, subject, subcontext, label, presence func (_m *MockNakamaModule) StreamUserKick(mode uint8, subject string, subcontext string, label string, presence runtime.Presence) error { ret := _m.Called(mode, subject, subcontext, label, presence) + if len(ret) == 0 { + panic("no return value specified for StreamUserKick") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, runtime.Presence) error); ok { r0 = rf(mode, subject, subcontext, label, presence) @@ -2160,13 +5893,49 @@ func (_m *MockNakamaModule) StreamUserKick(mode uint8, subject string, subcontex r0 = ret.Error(0) } - return r0 + return r0 +} + +// MockNakamaModule_StreamUserKick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserKick' +type MockNakamaModule_StreamUserKick_Call struct { + *mock.Call +} + +// StreamUserKick is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - presence runtime.Presence +func (_e *MockNakamaModule_Expecter) StreamUserKick(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, presence interface{}) *MockNakamaModule_StreamUserKick_Call { + return &MockNakamaModule_StreamUserKick_Call{Call: _e.mock.On("StreamUserKick", mode, subject, subcontext, label, presence)} +} + +func (_c *MockNakamaModule_StreamUserKick_Call) Run(run func(mode uint8, subject string, subcontext string, label string, presence runtime.Presence)) *MockNakamaModule_StreamUserKick_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(runtime.Presence)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserKick_Call) Return(_a0 error) *MockNakamaModule_StreamUserKick_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamUserKick_Call) RunAndReturn(run func(uint8, string, string, string, runtime.Presence) error) *MockNakamaModule_StreamUserKick_Call { + _c.Call.Return(run) + return _c } // StreamUserLeave provides a mock function with given fields: mode, subject, subcontext, label, userID, sessionID func (_m *MockNakamaModule) StreamUserLeave(mode uint8, subject string, subcontext string, label string, userID string, sessionID string) error { ret := _m.Called(mode, subject, subcontext, label, userID, sessionID) + if len(ret) == 0 { + panic("no return value specified for StreamUserLeave") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, string, string) error); ok { r0 = rf(mode, subject, subcontext, label, userID, sessionID) @@ -2177,10 +5946,47 @@ func (_m *MockNakamaModule) StreamUserLeave(mode uint8, subject string, subconte return r0 } +// MockNakamaModule_StreamUserLeave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserLeave' +type MockNakamaModule_StreamUserLeave_Call struct { + *mock.Call +} + +// StreamUserLeave is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - userID string +// - sessionID string +func (_e *MockNakamaModule_Expecter) StreamUserLeave(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, userID interface{}, sessionID interface{}) *MockNakamaModule_StreamUserLeave_Call { + return &MockNakamaModule_StreamUserLeave_Call{Call: _e.mock.On("StreamUserLeave", mode, subject, subcontext, label, userID, sessionID)} +} + +func (_c *MockNakamaModule_StreamUserLeave_Call) Run(run func(mode uint8, subject string, subcontext string, label string, userID string, sessionID string)) *MockNakamaModule_StreamUserLeave_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserLeave_Call) Return(_a0 error) *MockNakamaModule_StreamUserLeave_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamUserLeave_Call) RunAndReturn(run func(uint8, string, string, string, string, string) error) *MockNakamaModule_StreamUserLeave_Call { + _c.Call.Return(run) + return _c +} + // StreamUserList provides a mock function with given fields: mode, subject, subcontext, label, includeHidden, includeNotHidden func (_m *MockNakamaModule) StreamUserList(mode uint8, subject string, subcontext string, label string, includeHidden bool, includeNotHidden bool) ([]runtime.Presence, error) { ret := _m.Called(mode, subject, subcontext, label, includeHidden, includeNotHidden) + if len(ret) == 0 { + panic("no return value specified for StreamUserList") + } + var r0 []runtime.Presence var r1 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, bool, bool) ([]runtime.Presence, error)); ok { @@ -2203,10 +6009,47 @@ func (_m *MockNakamaModule) StreamUserList(mode uint8, subject string, subcontex return r0, r1 } +// MockNakamaModule_StreamUserList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserList' +type MockNakamaModule_StreamUserList_Call struct { + *mock.Call +} + +// StreamUserList is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - includeHidden bool +// - includeNotHidden bool +func (_e *MockNakamaModule_Expecter) StreamUserList(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, includeHidden interface{}, includeNotHidden interface{}) *MockNakamaModule_StreamUserList_Call { + return &MockNakamaModule_StreamUserList_Call{Call: _e.mock.On("StreamUserList", mode, subject, subcontext, label, includeHidden, includeNotHidden)} +} + +func (_c *MockNakamaModule_StreamUserList_Call) Run(run func(mode uint8, subject string, subcontext string, label string, includeHidden bool, includeNotHidden bool)) *MockNakamaModule_StreamUserList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(bool), args[5].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserList_Call) Return(_a0 []runtime.Presence, _a1 error) *MockNakamaModule_StreamUserList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_StreamUserList_Call) RunAndReturn(run func(uint8, string, string, string, bool, bool) ([]runtime.Presence, error)) *MockNakamaModule_StreamUserList_Call { + _c.Call.Return(run) + return _c +} + // StreamUserUpdate provides a mock function with given fields: mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status func (_m *MockNakamaModule) StreamUserUpdate(mode uint8, subject string, subcontext string, label string, userID string, sessionID string, hidden bool, persistence bool, status string) error { ret := _m.Called(mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status) + if len(ret) == 0 { + panic("no return value specified for StreamUserUpdate") + } + var r0 error if rf, ok := ret.Get(0).(func(uint8, string, string, string, string, string, bool, bool, string) error); ok { r0 = rf(mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status) @@ -2217,10 +6060,50 @@ func (_m *MockNakamaModule) StreamUserUpdate(mode uint8, subject string, subcont return r0 } +// MockNakamaModule_StreamUserUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamUserUpdate' +type MockNakamaModule_StreamUserUpdate_Call struct { + *mock.Call +} + +// StreamUserUpdate is a helper method to define mock.On call +// - mode uint8 +// - subject string +// - subcontext string +// - label string +// - userID string +// - sessionID string +// - hidden bool +// - persistence bool +// - status string +func (_e *MockNakamaModule_Expecter) StreamUserUpdate(mode interface{}, subject interface{}, subcontext interface{}, label interface{}, userID interface{}, sessionID interface{}, hidden interface{}, persistence interface{}, status interface{}) *MockNakamaModule_StreamUserUpdate_Call { + return &MockNakamaModule_StreamUserUpdate_Call{Call: _e.mock.On("StreamUserUpdate", mode, subject, subcontext, label, userID, sessionID, hidden, persistence, status)} +} + +func (_c *MockNakamaModule_StreamUserUpdate_Call) Run(run func(mode uint8, subject string, subcontext string, label string, userID string, sessionID string, hidden bool, persistence bool, status string)) *MockNakamaModule_StreamUserUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(uint8), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string), args[6].(bool), args[7].(bool), args[8].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_StreamUserUpdate_Call) Return(_a0 error) *MockNakamaModule_StreamUserUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_StreamUserUpdate_Call) RunAndReturn(run func(uint8, string, string, string, string, string, bool, bool, string) error) *MockNakamaModule_StreamUserUpdate_Call { + _c.Call.Return(run) + return _c +} + // SubscriptionGetByProductId provides a mock function with given fields: ctx, userID, productID func (_m *MockNakamaModule) SubscriptionGetByProductId(ctx context.Context, userID string, productID string) (*api.ValidatedSubscription, error) { ret := _m.Called(ctx, userID, productID) + if len(ret) == 0 { + panic("no return value specified for SubscriptionGetByProductId") + } + var r0 *api.ValidatedSubscription var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string) (*api.ValidatedSubscription, error)); ok { @@ -2243,6 +6126,36 @@ func (_m *MockNakamaModule) SubscriptionGetByProductId(ctx context.Context, user return r0, r1 } +// MockNakamaModule_SubscriptionGetByProductId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionGetByProductId' +type MockNakamaModule_SubscriptionGetByProductId_Call struct { + *mock.Call +} + +// SubscriptionGetByProductId is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - productID string +func (_e *MockNakamaModule_Expecter) SubscriptionGetByProductId(ctx interface{}, userID interface{}, productID interface{}) *MockNakamaModule_SubscriptionGetByProductId_Call { + return &MockNakamaModule_SubscriptionGetByProductId_Call{Call: _e.mock.On("SubscriptionGetByProductId", ctx, userID, productID)} +} + +func (_c *MockNakamaModule_SubscriptionGetByProductId_Call) Run(run func(ctx context.Context, userID string, productID string)) *MockNakamaModule_SubscriptionGetByProductId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_SubscriptionGetByProductId_Call) Return(_a0 *api.ValidatedSubscription, _a1 error) *MockNakamaModule_SubscriptionGetByProductId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_SubscriptionGetByProductId_Call) RunAndReturn(run func(context.Context, string, string) (*api.ValidatedSubscription, error)) *MockNakamaModule_SubscriptionGetByProductId_Call { + _c.Call.Return(run) + return _c +} + // SubscriptionValidateApple provides a mock function with given fields: ctx, userID, receipt, persist, passwordOverride func (_m *MockNakamaModule) SubscriptionValidateApple(ctx context.Context, userID string, receipt string, persist bool, passwordOverride ...string) (*api.ValidateSubscriptionResponse, error) { _va := make([]interface{}, len(passwordOverride)) @@ -2254,6 +6167,10 @@ func (_m *MockNakamaModule) SubscriptionValidateApple(ctx context.Context, userI _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for SubscriptionValidateApple") + } + var r0 *api.ValidateSubscriptionResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, ...string) (*api.ValidateSubscriptionResponse, error)); ok { @@ -2276,6 +6193,45 @@ func (_m *MockNakamaModule) SubscriptionValidateApple(ctx context.Context, userI return r0, r1 } +// MockNakamaModule_SubscriptionValidateApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionValidateApple' +type MockNakamaModule_SubscriptionValidateApple_Call struct { + *mock.Call +} + +// SubscriptionValidateApple is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - receipt string +// - persist bool +// - passwordOverride ...string +func (_e *MockNakamaModule_Expecter) SubscriptionValidateApple(ctx interface{}, userID interface{}, receipt interface{}, persist interface{}, passwordOverride ...interface{}) *MockNakamaModule_SubscriptionValidateApple_Call { + return &MockNakamaModule_SubscriptionValidateApple_Call{Call: _e.mock.On("SubscriptionValidateApple", + append([]interface{}{ctx, userID, receipt, persist}, passwordOverride...)...)} +} + +func (_c *MockNakamaModule_SubscriptionValidateApple_Call) Run(run func(ctx context.Context, userID string, receipt string, persist bool, passwordOverride ...string)) *MockNakamaModule_SubscriptionValidateApple_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_SubscriptionValidateApple_Call) Return(_a0 *api.ValidateSubscriptionResponse, _a1 error) *MockNakamaModule_SubscriptionValidateApple_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_SubscriptionValidateApple_Call) RunAndReturn(run func(context.Context, string, string, bool, ...string) (*api.ValidateSubscriptionResponse, error)) *MockNakamaModule_SubscriptionValidateApple_Call { + _c.Call.Return(run) + return _c +} + // SubscriptionValidateGoogle provides a mock function with given fields: ctx, userID, receipt, persist, overrides func (_m *MockNakamaModule) SubscriptionValidateGoogle(ctx context.Context, userID string, receipt string, persist bool, overrides ...struct { ClientEmail string @@ -2290,6 +6246,10 @@ func (_m *MockNakamaModule) SubscriptionValidateGoogle(ctx context.Context, user _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for SubscriptionValidateGoogle") + } + var r0 *api.ValidateSubscriptionResponse var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, ...struct { @@ -2321,10 +6281,65 @@ func (_m *MockNakamaModule) SubscriptionValidateGoogle(ctx context.Context, user return r0, r1 } +// MockNakamaModule_SubscriptionValidateGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionValidateGoogle' +type MockNakamaModule_SubscriptionValidateGoogle_Call struct { + *mock.Call +} + +// SubscriptionValidateGoogle is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - receipt string +// - persist bool +// - overrides ...struct{ClientEmail string;PrivateKey string} +func (_e *MockNakamaModule_Expecter) SubscriptionValidateGoogle(ctx interface{}, userID interface{}, receipt interface{}, persist interface{}, overrides ...interface{}) *MockNakamaModule_SubscriptionValidateGoogle_Call { + return &MockNakamaModule_SubscriptionValidateGoogle_Call{Call: _e.mock.On("SubscriptionValidateGoogle", + append([]interface{}{ctx, userID, receipt, persist}, overrides...)...)} +} + +func (_c *MockNakamaModule_SubscriptionValidateGoogle_Call) Run(run func(ctx context.Context, userID string, receipt string, persist bool, overrides ...struct { + ClientEmail string + PrivateKey string +})) *MockNakamaModule_SubscriptionValidateGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]struct { + ClientEmail string + PrivateKey string + }, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(struct { + ClientEmail string + PrivateKey string + }) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), variadicArgs...) + }) + return _c +} + +func (_c *MockNakamaModule_SubscriptionValidateGoogle_Call) Return(_a0 *api.ValidateSubscriptionResponse, _a1 error) *MockNakamaModule_SubscriptionValidateGoogle_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_SubscriptionValidateGoogle_Call) RunAndReturn(run func(context.Context, string, string, bool, ...struct { + ClientEmail string + PrivateKey string +}) (*api.ValidateSubscriptionResponse, error)) *MockNakamaModule_SubscriptionValidateGoogle_Call { + _c.Call.Return(run) + return _c +} + // SubscriptionsList provides a mock function with given fields: ctx, userID, limit, cursor func (_m *MockNakamaModule) SubscriptionsList(ctx context.Context, userID string, limit int, cursor string) (*api.SubscriptionList, error) { ret := _m.Called(ctx, userID, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for SubscriptionsList") + } + var r0 *api.SubscriptionList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, int, string) (*api.SubscriptionList, error)); ok { @@ -2347,10 +6362,45 @@ func (_m *MockNakamaModule) SubscriptionsList(ctx context.Context, userID string return r0, r1 } +// MockNakamaModule_SubscriptionsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionsList' +type MockNakamaModule_SubscriptionsList_Call struct { + *mock.Call +} + +// SubscriptionsList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) SubscriptionsList(ctx interface{}, userID interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_SubscriptionsList_Call { + return &MockNakamaModule_SubscriptionsList_Call{Call: _e.mock.On("SubscriptionsList", ctx, userID, limit, cursor)} +} + +func (_c *MockNakamaModule_SubscriptionsList_Call) Run(run func(ctx context.Context, userID string, limit int, cursor string)) *MockNakamaModule_SubscriptionsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_SubscriptionsList_Call) Return(_a0 *api.SubscriptionList, _a1 error) *MockNakamaModule_SubscriptionsList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_SubscriptionsList_Call) RunAndReturn(run func(context.Context, string, int, string) (*api.SubscriptionList, error)) *MockNakamaModule_SubscriptionsList_Call { + _c.Call.Return(run) + return _c +} + // TournamentAddAttempt provides a mock function with given fields: ctx, id, ownerID, count func (_m *MockNakamaModule) TournamentAddAttempt(ctx context.Context, id string, ownerID string, count int) error { ret := _m.Called(ctx, id, ownerID, count) + if len(ret) == 0 { + panic("no return value specified for TournamentAddAttempt") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, int) error); ok { r0 = rf(ctx, id, ownerID, count) @@ -2361,13 +6411,48 @@ func (_m *MockNakamaModule) TournamentAddAttempt(ctx context.Context, id string, return r0 } -// TournamentCreate provides a mock function with given fields: ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired -func (_m *MockNakamaModule) TournamentCreate(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}, title string, description string, category int, startTime int, endTime int, duration int, maxSize int, maxNumScore int, joinRequired bool) error { - ret := _m.Called(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired) +// MockNakamaModule_TournamentAddAttempt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentAddAttempt' +type MockNakamaModule_TournamentAddAttempt_Call struct { + *mock.Call +} + +// TournamentAddAttempt is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - count int +func (_e *MockNakamaModule_Expecter) TournamentAddAttempt(ctx interface{}, id interface{}, ownerID interface{}, count interface{}) *MockNakamaModule_TournamentAddAttempt_Call { + return &MockNakamaModule_TournamentAddAttempt_Call{Call: _e.mock.On("TournamentAddAttempt", ctx, id, ownerID, count)} +} + +func (_c *MockNakamaModule_TournamentAddAttempt_Call) Run(run func(ctx context.Context, id string, ownerID string, count int)) *MockNakamaModule_TournamentAddAttempt_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentAddAttempt_Call) Return(_a0 error) *MockNakamaModule_TournamentAddAttempt_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentAddAttempt_Call) RunAndReturn(run func(context.Context, string, string, int) error) *MockNakamaModule_TournamentAddAttempt_Call { + _c.Call.Return(run) + return _c +} + +// TournamentCreate provides a mock function with given fields: ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired, enableRanks +func (_m *MockNakamaModule) TournamentCreate(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}, title string, description string, category int, startTime int, endTime int, duration int, maxSize int, maxNumScore int, joinRequired bool, enableRanks bool) error { + ret := _m.Called(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired, enableRanks) + + if len(ret) == 0 { + panic("no return value specified for TournamentCreate") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, bool, string, string, string, map[string]interface{}, string, string, int, int, int, int, int, int, bool) error); ok { - r0 = rf(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired) + if rf, ok := ret.Get(0).(func(context.Context, string, bool, string, string, string, map[string]interface{}, string, string, int, int, int, int, int, int, bool, bool) error); ok { + r0 = rf(ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired, enableRanks) } else { r0 = ret.Error(0) } @@ -2375,10 +6460,58 @@ func (_m *MockNakamaModule) TournamentCreate(ctx context.Context, id string, aut return r0 } +// MockNakamaModule_TournamentCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentCreate' +type MockNakamaModule_TournamentCreate_Call struct { + *mock.Call +} + +// TournamentCreate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - authoritative bool +// - sortOrder string +// - operator string +// - resetSchedule string +// - metadata map[string]interface{} +// - title string +// - description string +// - category int +// - startTime int +// - endTime int +// - duration int +// - maxSize int +// - maxNumScore int +// - joinRequired bool +// - enableRanks bool +func (_e *MockNakamaModule_Expecter) TournamentCreate(ctx interface{}, id interface{}, authoritative interface{}, sortOrder interface{}, operator interface{}, resetSchedule interface{}, metadata interface{}, title interface{}, description interface{}, category interface{}, startTime interface{}, endTime interface{}, duration interface{}, maxSize interface{}, maxNumScore interface{}, joinRequired interface{}, enableRanks interface{}) *MockNakamaModule_TournamentCreate_Call { + return &MockNakamaModule_TournamentCreate_Call{Call: _e.mock.On("TournamentCreate", ctx, id, authoritative, sortOrder, operator, resetSchedule, metadata, title, description, category, startTime, endTime, duration, maxSize, maxNumScore, joinRequired, enableRanks)} +} + +func (_c *MockNakamaModule_TournamentCreate_Call) Run(run func(ctx context.Context, id string, authoritative bool, sortOrder string, operator string, resetSchedule string, metadata map[string]interface{}, title string, description string, category int, startTime int, endTime int, duration int, maxSize int, maxNumScore int, joinRequired bool, enableRanks bool)) *MockNakamaModule_TournamentCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(bool), args[3].(string), args[4].(string), args[5].(string), args[6].(map[string]interface{}), args[7].(string), args[8].(string), args[9].(int), args[10].(int), args[11].(int), args[12].(int), args[13].(int), args[14].(int), args[15].(bool), args[16].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentCreate_Call) Return(_a0 error) *MockNakamaModule_TournamentCreate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentCreate_Call) RunAndReturn(run func(context.Context, string, bool, string, string, string, map[string]interface{}, string, string, int, int, int, int, int, int, bool, bool) error) *MockNakamaModule_TournamentCreate_Call { + _c.Call.Return(run) + return _c +} + // TournamentDelete provides a mock function with given fields: ctx, id func (_m *MockNakamaModule) TournamentDelete(ctx context.Context, id string) error { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for TournamentDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { r0 = rf(ctx, id) @@ -2389,10 +6522,43 @@ func (_m *MockNakamaModule) TournamentDelete(ctx context.Context, id string) err return r0 } +// MockNakamaModule_TournamentDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentDelete' +type MockNakamaModule_TournamentDelete_Call struct { + *mock.Call +} + +// TournamentDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) TournamentDelete(ctx interface{}, id interface{}) *MockNakamaModule_TournamentDelete_Call { + return &MockNakamaModule_TournamentDelete_Call{Call: _e.mock.On("TournamentDelete", ctx, id)} +} + +func (_c *MockNakamaModule_TournamentDelete_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_TournamentDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentDelete_Call) Return(_a0 error) *MockNakamaModule_TournamentDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentDelete_Call) RunAndReturn(run func(context.Context, string) error) *MockNakamaModule_TournamentDelete_Call { + _c.Call.Return(run) + return _c +} + // TournamentJoin provides a mock function with given fields: ctx, id, ownerID, username func (_m *MockNakamaModule) TournamentJoin(ctx context.Context, id string, ownerID string, username string) error { ret := _m.Called(ctx, id, ownerID, username) + if len(ret) == 0 { + panic("no return value specified for TournamentJoin") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { r0 = rf(ctx, id, ownerID, username) @@ -2403,10 +6569,45 @@ func (_m *MockNakamaModule) TournamentJoin(ctx context.Context, id string, owner return r0 } +// MockNakamaModule_TournamentJoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentJoin' +type MockNakamaModule_TournamentJoin_Call struct { + *mock.Call +} + +// TournamentJoin is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - username string +func (_e *MockNakamaModule_Expecter) TournamentJoin(ctx interface{}, id interface{}, ownerID interface{}, username interface{}) *MockNakamaModule_TournamentJoin_Call { + return &MockNakamaModule_TournamentJoin_Call{Call: _e.mock.On("TournamentJoin", ctx, id, ownerID, username)} +} + +func (_c *MockNakamaModule_TournamentJoin_Call) Run(run func(ctx context.Context, id string, ownerID string, username string)) *MockNakamaModule_TournamentJoin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentJoin_Call) Return(_a0 error) *MockNakamaModule_TournamentJoin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentJoin_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockNakamaModule_TournamentJoin_Call { + _c.Call.Return(run) + return _c +} + // TournamentList provides a mock function with given fields: ctx, categoryStart, categoryEnd, startTime, endTime, limit, cursor func (_m *MockNakamaModule) TournamentList(ctx context.Context, categoryStart int, categoryEnd int, startTime int, endTime int, limit int, cursor string) (*api.TournamentList, error) { ret := _m.Called(ctx, categoryStart, categoryEnd, startTime, endTime, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for TournamentList") + } + var r0 *api.TournamentList var r1 error if rf, ok := ret.Get(0).(func(context.Context, int, int, int, int, int, string) (*api.TournamentList, error)); ok { @@ -2429,10 +6630,95 @@ func (_m *MockNakamaModule) TournamentList(ctx context.Context, categoryStart in return r0, r1 } +// MockNakamaModule_TournamentList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentList' +type MockNakamaModule_TournamentList_Call struct { + *mock.Call +} + +// TournamentList is a helper method to define mock.On call +// - ctx context.Context +// - categoryStart int +// - categoryEnd int +// - startTime int +// - endTime int +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) TournamentList(ctx interface{}, categoryStart interface{}, categoryEnd interface{}, startTime interface{}, endTime interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_TournamentList_Call { + return &MockNakamaModule_TournamentList_Call{Call: _e.mock.On("TournamentList", ctx, categoryStart, categoryEnd, startTime, endTime, limit, cursor)} +} + +func (_c *MockNakamaModule_TournamentList_Call) Run(run func(ctx context.Context, categoryStart int, categoryEnd int, startTime int, endTime int, limit int, cursor string)) *MockNakamaModule_TournamentList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int), args[2].(int), args[3].(int), args[4].(int), args[5].(int), args[6].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentList_Call) Return(_a0 *api.TournamentList, _a1 error) *MockNakamaModule_TournamentList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_TournamentList_Call) RunAndReturn(run func(context.Context, int, int, int, int, int, string) (*api.TournamentList, error)) *MockNakamaModule_TournamentList_Call { + _c.Call.Return(run) + return _c +} + +// TournamentRanksDisable provides a mock function with given fields: ctx, id +func (_m *MockNakamaModule) TournamentRanksDisable(ctx context.Context, id string) error { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for TournamentRanksDisable") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_TournamentRanksDisable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentRanksDisable' +type MockNakamaModule_TournamentRanksDisable_Call struct { + *mock.Call +} + +// TournamentRanksDisable is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockNakamaModule_Expecter) TournamentRanksDisable(ctx interface{}, id interface{}) *MockNakamaModule_TournamentRanksDisable_Call { + return &MockNakamaModule_TournamentRanksDisable_Call{Call: _e.mock.On("TournamentRanksDisable", ctx, id)} +} + +func (_c *MockNakamaModule_TournamentRanksDisable_Call) Run(run func(ctx context.Context, id string)) *MockNakamaModule_TournamentRanksDisable_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentRanksDisable_Call) Return(_a0 error) *MockNakamaModule_TournamentRanksDisable_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentRanksDisable_Call) RunAndReturn(run func(context.Context, string) error) *MockNakamaModule_TournamentRanksDisable_Call { + _c.Call.Return(run) + return _c +} + // TournamentRecordDelete provides a mock function with given fields: ctx, id, ownerID func (_m *MockNakamaModule) TournamentRecordDelete(ctx context.Context, id string, ownerID string) error { ret := _m.Called(ctx, id, ownerID) + if len(ret) == 0 { + panic("no return value specified for TournamentRecordDelete") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, id, ownerID) @@ -2443,10 +6729,44 @@ func (_m *MockNakamaModule) TournamentRecordDelete(ctx context.Context, id strin return r0 } +// MockNakamaModule_TournamentRecordDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentRecordDelete' +type MockNakamaModule_TournamentRecordDelete_Call struct { + *mock.Call +} + +// TournamentRecordDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +func (_e *MockNakamaModule_Expecter) TournamentRecordDelete(ctx interface{}, id interface{}, ownerID interface{}) *MockNakamaModule_TournamentRecordDelete_Call { + return &MockNakamaModule_TournamentRecordDelete_Call{Call: _e.mock.On("TournamentRecordDelete", ctx, id, ownerID)} +} + +func (_c *MockNakamaModule_TournamentRecordDelete_Call) Run(run func(ctx context.Context, id string, ownerID string)) *MockNakamaModule_TournamentRecordDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordDelete_Call) Return(_a0 error) *MockNakamaModule_TournamentRecordDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordDelete_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_TournamentRecordDelete_Call { + _c.Call.Return(run) + return _c +} + // TournamentRecordWrite provides a mock function with given fields: ctx, id, ownerID, username, score, subscore, metadata, operatorOverride func (_m *MockNakamaModule) TournamentRecordWrite(ctx context.Context, id string, ownerID string, username string, score int64, subscore int64, metadata map[string]interface{}, operatorOverride *int) (*api.LeaderboardRecord, error) { ret := _m.Called(ctx, id, ownerID, username, score, subscore, metadata, operatorOverride) + if len(ret) == 0 { + panic("no return value specified for TournamentRecordWrite") + } + var r0 *api.LeaderboardRecord var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, int64, map[string]interface{}, *int) (*api.LeaderboardRecord, error)); ok { @@ -2469,10 +6789,49 @@ func (_m *MockNakamaModule) TournamentRecordWrite(ctx context.Context, id string return r0, r1 } +// MockNakamaModule_TournamentRecordWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentRecordWrite' +type MockNakamaModule_TournamentRecordWrite_Call struct { + *mock.Call +} + +// TournamentRecordWrite is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - username string +// - score int64 +// - subscore int64 +// - metadata map[string]interface{} +// - operatorOverride *int +func (_e *MockNakamaModule_Expecter) TournamentRecordWrite(ctx interface{}, id interface{}, ownerID interface{}, username interface{}, score interface{}, subscore interface{}, metadata interface{}, operatorOverride interface{}) *MockNakamaModule_TournamentRecordWrite_Call { + return &MockNakamaModule_TournamentRecordWrite_Call{Call: _e.mock.On("TournamentRecordWrite", ctx, id, ownerID, username, score, subscore, metadata, operatorOverride)} +} + +func (_c *MockNakamaModule_TournamentRecordWrite_Call) Run(run func(ctx context.Context, id string, ownerID string, username string, score int64, subscore int64, metadata map[string]interface{}, operatorOverride *int)) *MockNakamaModule_TournamentRecordWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64), args[5].(int64), args[6].(map[string]interface{}), args[7].(*int)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordWrite_Call) Return(_a0 *api.LeaderboardRecord, _a1 error) *MockNakamaModule_TournamentRecordWrite_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordWrite_Call) RunAndReturn(run func(context.Context, string, string, string, int64, int64, map[string]interface{}, *int) (*api.LeaderboardRecord, error)) *MockNakamaModule_TournamentRecordWrite_Call { + _c.Call.Return(run) + return _c +} + // TournamentRecordsHaystack provides a mock function with given fields: ctx, id, ownerID, limit, cursor, expiry func (_m *MockNakamaModule) TournamentRecordsHaystack(ctx context.Context, id string, ownerID string, limit int, cursor string, expiry int64) (*api.TournamentRecordList, error) { ret := _m.Called(ctx, id, ownerID, limit, cursor, expiry) + if len(ret) == 0 { + panic("no return value specified for TournamentRecordsHaystack") + } + var r0 *api.TournamentRecordList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, string, int, string, int64) (*api.TournamentRecordList, error)); ok { @@ -2495,10 +6854,47 @@ func (_m *MockNakamaModule) TournamentRecordsHaystack(ctx context.Context, id st return r0, r1 } +// MockNakamaModule_TournamentRecordsHaystack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentRecordsHaystack' +type MockNakamaModule_TournamentRecordsHaystack_Call struct { + *mock.Call +} + +// TournamentRecordsHaystack is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - ownerID string +// - limit int +// - cursor string +// - expiry int64 +func (_e *MockNakamaModule_Expecter) TournamentRecordsHaystack(ctx interface{}, id interface{}, ownerID interface{}, limit interface{}, cursor interface{}, expiry interface{}) *MockNakamaModule_TournamentRecordsHaystack_Call { + return &MockNakamaModule_TournamentRecordsHaystack_Call{Call: _e.mock.On("TournamentRecordsHaystack", ctx, id, ownerID, limit, cursor, expiry)} +} + +func (_c *MockNakamaModule_TournamentRecordsHaystack_Call) Run(run func(ctx context.Context, id string, ownerID string, limit int, cursor string, expiry int64)) *MockNakamaModule_TournamentRecordsHaystack_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(string), args[5].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordsHaystack_Call) Return(_a0 *api.TournamentRecordList, _a1 error) *MockNakamaModule_TournamentRecordsHaystack_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordsHaystack_Call) RunAndReturn(run func(context.Context, string, string, int, string, int64) (*api.TournamentRecordList, error)) *MockNakamaModule_TournamentRecordsHaystack_Call { + _c.Call.Return(run) + return _c +} + // TournamentRecordsList provides a mock function with given fields: ctx, tournamentId, ownerIDs, limit, cursor, overrideExpiry func (_m *MockNakamaModule) TournamentRecordsList(ctx context.Context, tournamentId string, ownerIDs []string, limit int, cursor string, overrideExpiry int64) ([]*api.LeaderboardRecord, []*api.LeaderboardRecord, string, string, error) { ret := _m.Called(ctx, tournamentId, ownerIDs, limit, cursor, overrideExpiry) + if len(ret) == 0 { + panic("no return value specified for TournamentRecordsList") + } + var r0 []*api.LeaderboardRecord var r1 []*api.LeaderboardRecord var r2 string @@ -2544,10 +6940,47 @@ func (_m *MockNakamaModule) TournamentRecordsList(ctx context.Context, tournamen return r0, r1, r2, r3, r4 } +// MockNakamaModule_TournamentRecordsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentRecordsList' +type MockNakamaModule_TournamentRecordsList_Call struct { + *mock.Call +} + +// TournamentRecordsList is a helper method to define mock.On call +// - ctx context.Context +// - tournamentId string +// - ownerIDs []string +// - limit int +// - cursor string +// - overrideExpiry int64 +func (_e *MockNakamaModule_Expecter) TournamentRecordsList(ctx interface{}, tournamentId interface{}, ownerIDs interface{}, limit interface{}, cursor interface{}, overrideExpiry interface{}) *MockNakamaModule_TournamentRecordsList_Call { + return &MockNakamaModule_TournamentRecordsList_Call{Call: _e.mock.On("TournamentRecordsList", ctx, tournamentId, ownerIDs, limit, cursor, overrideExpiry)} +} + +func (_c *MockNakamaModule_TournamentRecordsList_Call) Run(run func(ctx context.Context, tournamentId string, ownerIDs []string, limit int, cursor string, overrideExpiry int64)) *MockNakamaModule_TournamentRecordsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(int), args[4].(string), args[5].(int64)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordsList_Call) Return(records []*api.LeaderboardRecord, ownerRecords []*api.LeaderboardRecord, prevCursor string, nextCursor string, err error) *MockNakamaModule_TournamentRecordsList_Call { + _c.Call.Return(records, ownerRecords, prevCursor, nextCursor, err) + return _c +} + +func (_c *MockNakamaModule_TournamentRecordsList_Call) RunAndReturn(run func(context.Context, string, []string, int, string, int64) ([]*api.LeaderboardRecord, []*api.LeaderboardRecord, string, string, error)) *MockNakamaModule_TournamentRecordsList_Call { + _c.Call.Return(run) + return _c +} + // TournamentsGetId provides a mock function with given fields: ctx, tournamentIDs func (_m *MockNakamaModule) TournamentsGetId(ctx context.Context, tournamentIDs []string) ([]*api.Tournament, error) { ret := _m.Called(ctx, tournamentIDs) + if len(ret) == 0 { + panic("no return value specified for TournamentsGetId") + } + var r0 []*api.Tournament var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*api.Tournament, error)); ok { @@ -2570,24 +7003,91 @@ func (_m *MockNakamaModule) TournamentsGetId(ctx context.Context, tournamentIDs return r0, r1 } +// MockNakamaModule_TournamentsGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TournamentsGetId' +type MockNakamaModule_TournamentsGetId_Call struct { + *mock.Call +} + +// TournamentsGetId is a helper method to define mock.On call +// - ctx context.Context +// - tournamentIDs []string +func (_e *MockNakamaModule_Expecter) TournamentsGetId(ctx interface{}, tournamentIDs interface{}) *MockNakamaModule_TournamentsGetId_Call { + return &MockNakamaModule_TournamentsGetId_Call{Call: _e.mock.On("TournamentsGetId", ctx, tournamentIDs)} +} + +func (_c *MockNakamaModule_TournamentsGetId_Call) Run(run func(ctx context.Context, tournamentIDs []string)) *MockNakamaModule_TournamentsGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_TournamentsGetId_Call) Return(_a0 []*api.Tournament, _a1 error) *MockNakamaModule_TournamentsGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_TournamentsGetId_Call) RunAndReturn(run func(context.Context, []string) ([]*api.Tournament, error)) *MockNakamaModule_TournamentsGetId_Call { + _c.Call.Return(run) + return _c +} + // UnlinkApple provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) UnlinkApple(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { - r0 = rf(ctx, userID, token) - } else { - r0 = ret.Error(0) - } + if len(ret) == 0 { + panic("no return value specified for UnlinkApple") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, userID, token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockNakamaModule_UnlinkApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkApple' +type MockNakamaModule_UnlinkApple_Call struct { + *mock.Call +} + +// UnlinkApple is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) UnlinkApple(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_UnlinkApple_Call { + return &MockNakamaModule_UnlinkApple_Call{Call: _e.mock.On("UnlinkApple", ctx, userID, token)} +} + +func (_c *MockNakamaModule_UnlinkApple_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_UnlinkApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkApple_Call) Return(_a0 error) *MockNakamaModule_UnlinkApple_Call { + _c.Call.Return(_a0) + return _c +} - return r0 +func (_c *MockNakamaModule_UnlinkApple_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkApple_Call { + _c.Call.Return(run) + return _c } // UnlinkCustom provides a mock function with given fields: ctx, userID, customID func (_m *MockNakamaModule) UnlinkCustom(ctx context.Context, userID string, customID string) error { ret := _m.Called(ctx, userID, customID) + if len(ret) == 0 { + panic("no return value specified for UnlinkCustom") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, customID) @@ -2598,10 +7098,44 @@ func (_m *MockNakamaModule) UnlinkCustom(ctx context.Context, userID string, cus return r0 } +// MockNakamaModule_UnlinkCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkCustom' +type MockNakamaModule_UnlinkCustom_Call struct { + *mock.Call +} + +// UnlinkCustom is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - customID string +func (_e *MockNakamaModule_Expecter) UnlinkCustom(ctx interface{}, userID interface{}, customID interface{}) *MockNakamaModule_UnlinkCustom_Call { + return &MockNakamaModule_UnlinkCustom_Call{Call: _e.mock.On("UnlinkCustom", ctx, userID, customID)} +} + +func (_c *MockNakamaModule_UnlinkCustom_Call) Run(run func(ctx context.Context, userID string, customID string)) *MockNakamaModule_UnlinkCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkCustom_Call) Return(_a0 error) *MockNakamaModule_UnlinkCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkCustom_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkCustom_Call { + _c.Call.Return(run) + return _c +} + // UnlinkDevice provides a mock function with given fields: ctx, userID, deviceID func (_m *MockNakamaModule) UnlinkDevice(ctx context.Context, userID string, deviceID string) error { ret := _m.Called(ctx, userID, deviceID) + if len(ret) == 0 { + panic("no return value specified for UnlinkDevice") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, deviceID) @@ -2612,10 +7146,44 @@ func (_m *MockNakamaModule) UnlinkDevice(ctx context.Context, userID string, dev return r0 } +// MockNakamaModule_UnlinkDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkDevice' +type MockNakamaModule_UnlinkDevice_Call struct { + *mock.Call +} + +// UnlinkDevice is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - deviceID string +func (_e *MockNakamaModule_Expecter) UnlinkDevice(ctx interface{}, userID interface{}, deviceID interface{}) *MockNakamaModule_UnlinkDevice_Call { + return &MockNakamaModule_UnlinkDevice_Call{Call: _e.mock.On("UnlinkDevice", ctx, userID, deviceID)} +} + +func (_c *MockNakamaModule_UnlinkDevice_Call) Run(run func(ctx context.Context, userID string, deviceID string)) *MockNakamaModule_UnlinkDevice_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkDevice_Call) Return(_a0 error) *MockNakamaModule_UnlinkDevice_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkDevice_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkDevice_Call { + _c.Call.Return(run) + return _c +} + // UnlinkEmail provides a mock function with given fields: ctx, userID, email func (_m *MockNakamaModule) UnlinkEmail(ctx context.Context, userID string, email string) error { ret := _m.Called(ctx, userID, email) + if len(ret) == 0 { + panic("no return value specified for UnlinkEmail") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, email) @@ -2626,10 +7194,44 @@ func (_m *MockNakamaModule) UnlinkEmail(ctx context.Context, userID string, emai return r0 } +// MockNakamaModule_UnlinkEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkEmail' +type MockNakamaModule_UnlinkEmail_Call struct { + *mock.Call +} + +// UnlinkEmail is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - email string +func (_e *MockNakamaModule_Expecter) UnlinkEmail(ctx interface{}, userID interface{}, email interface{}) *MockNakamaModule_UnlinkEmail_Call { + return &MockNakamaModule_UnlinkEmail_Call{Call: _e.mock.On("UnlinkEmail", ctx, userID, email)} +} + +func (_c *MockNakamaModule_UnlinkEmail_Call) Run(run func(ctx context.Context, userID string, email string)) *MockNakamaModule_UnlinkEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkEmail_Call) Return(_a0 error) *MockNakamaModule_UnlinkEmail_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkEmail_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkEmail_Call { + _c.Call.Return(run) + return _c +} + // UnlinkFacebook provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) UnlinkFacebook(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) + if len(ret) == 0 { + panic("no return value specified for UnlinkFacebook") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, token) @@ -2640,10 +7242,44 @@ func (_m *MockNakamaModule) UnlinkFacebook(ctx context.Context, userID string, t return r0 } +// MockNakamaModule_UnlinkFacebook_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkFacebook' +type MockNakamaModule_UnlinkFacebook_Call struct { + *mock.Call +} + +// UnlinkFacebook is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) UnlinkFacebook(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_UnlinkFacebook_Call { + return &MockNakamaModule_UnlinkFacebook_Call{Call: _e.mock.On("UnlinkFacebook", ctx, userID, token)} +} + +func (_c *MockNakamaModule_UnlinkFacebook_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_UnlinkFacebook_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkFacebook_Call) Return(_a0 error) *MockNakamaModule_UnlinkFacebook_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkFacebook_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkFacebook_Call { + _c.Call.Return(run) + return _c +} + // UnlinkFacebookInstantGame provides a mock function with given fields: ctx, userID, signedPlayerInfo func (_m *MockNakamaModule) UnlinkFacebookInstantGame(ctx context.Context, userID string, signedPlayerInfo string) error { ret := _m.Called(ctx, userID, signedPlayerInfo) + if len(ret) == 0 { + panic("no return value specified for UnlinkFacebookInstantGame") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, signedPlayerInfo) @@ -2654,10 +7290,44 @@ func (_m *MockNakamaModule) UnlinkFacebookInstantGame(ctx context.Context, userI return r0 } +// MockNakamaModule_UnlinkFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkFacebookInstantGame' +type MockNakamaModule_UnlinkFacebookInstantGame_Call struct { + *mock.Call +} + +// UnlinkFacebookInstantGame is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - signedPlayerInfo string +func (_e *MockNakamaModule_Expecter) UnlinkFacebookInstantGame(ctx interface{}, userID interface{}, signedPlayerInfo interface{}) *MockNakamaModule_UnlinkFacebookInstantGame_Call { + return &MockNakamaModule_UnlinkFacebookInstantGame_Call{Call: _e.mock.On("UnlinkFacebookInstantGame", ctx, userID, signedPlayerInfo)} +} + +func (_c *MockNakamaModule_UnlinkFacebookInstantGame_Call) Run(run func(ctx context.Context, userID string, signedPlayerInfo string)) *MockNakamaModule_UnlinkFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkFacebookInstantGame_Call) Return(_a0 error) *MockNakamaModule_UnlinkFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkFacebookInstantGame_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + // UnlinkGameCenter provides a mock function with given fields: ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl func (_m *MockNakamaModule) UnlinkGameCenter(ctx context.Context, userID string, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string) error { ret := _m.Called(ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl) + if len(ret) == 0 { + panic("no return value specified for UnlinkGameCenter") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, string, string, string) error); ok { r0 = rf(ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl) @@ -2668,10 +7338,49 @@ func (_m *MockNakamaModule) UnlinkGameCenter(ctx context.Context, userID string, return r0 } +// MockNakamaModule_UnlinkGameCenter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkGameCenter' +type MockNakamaModule_UnlinkGameCenter_Call struct { + *mock.Call +} + +// UnlinkGameCenter is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - playerID string +// - bundleID string +// - timestamp int64 +// - salt string +// - signature string +// - publicKeyUrl string +func (_e *MockNakamaModule_Expecter) UnlinkGameCenter(ctx interface{}, userID interface{}, playerID interface{}, bundleID interface{}, timestamp interface{}, salt interface{}, signature interface{}, publicKeyUrl interface{}) *MockNakamaModule_UnlinkGameCenter_Call { + return &MockNakamaModule_UnlinkGameCenter_Call{Call: _e.mock.On("UnlinkGameCenter", ctx, userID, playerID, bundleID, timestamp, salt, signature, publicKeyUrl)} +} + +func (_c *MockNakamaModule_UnlinkGameCenter_Call) Run(run func(ctx context.Context, userID string, playerID string, bundleID string, timestamp int64, salt string, signature string, publicKeyUrl string)) *MockNakamaModule_UnlinkGameCenter_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int64), args[5].(string), args[6].(string), args[7].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkGameCenter_Call) Return(_a0 error) *MockNakamaModule_UnlinkGameCenter_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkGameCenter_Call) RunAndReturn(run func(context.Context, string, string, string, int64, string, string, string) error) *MockNakamaModule_UnlinkGameCenter_Call { + _c.Call.Return(run) + return _c +} + // UnlinkGoogle provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) UnlinkGoogle(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) + if len(ret) == 0 { + panic("no return value specified for UnlinkGoogle") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, token) @@ -2682,10 +7391,44 @@ func (_m *MockNakamaModule) UnlinkGoogle(ctx context.Context, userID string, tok return r0 } +// MockNakamaModule_UnlinkGoogle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkGoogle' +type MockNakamaModule_UnlinkGoogle_Call struct { + *mock.Call +} + +// UnlinkGoogle is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) UnlinkGoogle(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_UnlinkGoogle_Call { + return &MockNakamaModule_UnlinkGoogle_Call{Call: _e.mock.On("UnlinkGoogle", ctx, userID, token)} +} + +func (_c *MockNakamaModule_UnlinkGoogle_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_UnlinkGoogle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkGoogle_Call) Return(_a0 error) *MockNakamaModule_UnlinkGoogle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkGoogle_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkGoogle_Call { + _c.Call.Return(run) + return _c +} + // UnlinkSteam provides a mock function with given fields: ctx, userID, token func (_m *MockNakamaModule) UnlinkSteam(ctx context.Context, userID string, token string) error { ret := _m.Called(ctx, userID, token) + if len(ret) == 0 { + panic("no return value specified for UnlinkSteam") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { r0 = rf(ctx, userID, token) @@ -2696,10 +7439,44 @@ func (_m *MockNakamaModule) UnlinkSteam(ctx context.Context, userID string, toke return r0 } +// MockNakamaModule_UnlinkSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlinkSteam' +type MockNakamaModule_UnlinkSteam_Call struct { + *mock.Call +} + +// UnlinkSteam is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - token string +func (_e *MockNakamaModule_Expecter) UnlinkSteam(ctx interface{}, userID interface{}, token interface{}) *MockNakamaModule_UnlinkSteam_Call { + return &MockNakamaModule_UnlinkSteam_Call{Call: _e.mock.On("UnlinkSteam", ctx, userID, token)} +} + +func (_c *MockNakamaModule_UnlinkSteam_Call) Run(run func(ctx context.Context, userID string, token string)) *MockNakamaModule_UnlinkSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UnlinkSteam_Call) Return(_a0 error) *MockNakamaModule_UnlinkSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UnlinkSteam_Call) RunAndReturn(run func(context.Context, string, string) error) *MockNakamaModule_UnlinkSteam_Call { + _c.Call.Return(run) + return _c +} + // UserGroupsList provides a mock function with given fields: ctx, userID, limit, state, cursor func (_m *MockNakamaModule) UserGroupsList(ctx context.Context, userID string, limit int, state *int, cursor string) ([]*api.UserGroupList_UserGroup, string, error) { ret := _m.Called(ctx, userID, limit, state, cursor) + if len(ret) == 0 { + panic("no return value specified for UserGroupsList") + } + var r0 []*api.UserGroupList_UserGroup var r1 string var r2 error @@ -2729,10 +7506,46 @@ func (_m *MockNakamaModule) UserGroupsList(ctx context.Context, userID string, l return r0, r1, r2 } +// MockNakamaModule_UserGroupsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserGroupsList' +type MockNakamaModule_UserGroupsList_Call struct { + *mock.Call +} + +// UserGroupsList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - state *int +// - cursor string +func (_e *MockNakamaModule_Expecter) UserGroupsList(ctx interface{}, userID interface{}, limit interface{}, state interface{}, cursor interface{}) *MockNakamaModule_UserGroupsList_Call { + return &MockNakamaModule_UserGroupsList_Call{Call: _e.mock.On("UserGroupsList", ctx, userID, limit, state, cursor)} +} + +func (_c *MockNakamaModule_UserGroupsList_Call) Run(run func(ctx context.Context, userID string, limit int, state *int, cursor string)) *MockNakamaModule_UserGroupsList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(*int), args[4].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_UserGroupsList_Call) Return(_a0 []*api.UserGroupList_UserGroup, _a1 string, _a2 error) *MockNakamaModule_UserGroupsList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_UserGroupsList_Call) RunAndReturn(run func(context.Context, string, int, *int, string) ([]*api.UserGroupList_UserGroup, string, error)) *MockNakamaModule_UserGroupsList_Call { + _c.Call.Return(run) + return _c +} + // UsersBanId provides a mock function with given fields: ctx, userIDs func (_m *MockNakamaModule) UsersBanId(ctx context.Context, userIDs []string) error { ret := _m.Called(ctx, userIDs) + if len(ret) == 0 { + panic("no return value specified for UsersBanId") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, []string) error); ok { r0 = rf(ctx, userIDs) @@ -2743,10 +7556,103 @@ func (_m *MockNakamaModule) UsersBanId(ctx context.Context, userIDs []string) er return r0 } +// MockNakamaModule_UsersBanId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersBanId' +type MockNakamaModule_UsersBanId_Call struct { + *mock.Call +} + +// UsersBanId is a helper method to define mock.On call +// - ctx context.Context +// - userIDs []string +func (_e *MockNakamaModule_Expecter) UsersBanId(ctx interface{}, userIDs interface{}) *MockNakamaModule_UsersBanId_Call { + return &MockNakamaModule_UsersBanId_Call{Call: _e.mock.On("UsersBanId", ctx, userIDs)} +} + +func (_c *MockNakamaModule_UsersBanId_Call) Run(run func(ctx context.Context, userIDs []string)) *MockNakamaModule_UsersBanId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersBanId_Call) Return(_a0 error) *MockNakamaModule_UsersBanId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UsersBanId_Call) RunAndReturn(run func(context.Context, []string) error) *MockNakamaModule_UsersBanId_Call { + _c.Call.Return(run) + return _c +} + +// UsersGetFriendStatus provides a mock function with given fields: ctx, userID, userIDs +func (_m *MockNakamaModule) UsersGetFriendStatus(ctx context.Context, userID string, userIDs []string) ([]*api.Friend, error) { + ret := _m.Called(ctx, userID, userIDs) + + if len(ret) == 0 { + panic("no return value specified for UsersGetFriendStatus") + } + + var r0 []*api.Friend + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, []string) ([]*api.Friend, error)); ok { + return rf(ctx, userID, userIDs) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []string) []*api.Friend); ok { + r0 = rf(ctx, userID, userIDs) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.Friend) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok { + r1 = rf(ctx, userID, userIDs) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockNakamaModule_UsersGetFriendStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersGetFriendStatus' +type MockNakamaModule_UsersGetFriendStatus_Call struct { + *mock.Call +} + +// UsersGetFriendStatus is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - userIDs []string +func (_e *MockNakamaModule_Expecter) UsersGetFriendStatus(ctx interface{}, userID interface{}, userIDs interface{}) *MockNakamaModule_UsersGetFriendStatus_Call { + return &MockNakamaModule_UsersGetFriendStatus_Call{Call: _e.mock.On("UsersGetFriendStatus", ctx, userID, userIDs)} +} + +func (_c *MockNakamaModule_UsersGetFriendStatus_Call) Run(run func(ctx context.Context, userID string, userIDs []string)) *MockNakamaModule_UsersGetFriendStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersGetFriendStatus_Call) Return(_a0 []*api.Friend, _a1 error) *MockNakamaModule_UsersGetFriendStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_UsersGetFriendStatus_Call) RunAndReturn(run func(context.Context, string, []string) ([]*api.Friend, error)) *MockNakamaModule_UsersGetFriendStatus_Call { + _c.Call.Return(run) + return _c +} + // UsersGetId provides a mock function with given fields: ctx, userIDs, facebookIDs func (_m *MockNakamaModule) UsersGetId(ctx context.Context, userIDs []string, facebookIDs []string) ([]*api.User, error) { ret := _m.Called(ctx, userIDs, facebookIDs) + if len(ret) == 0 { + panic("no return value specified for UsersGetId") + } + var r0 []*api.User var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string, []string) ([]*api.User, error)); ok { @@ -2769,10 +7675,44 @@ func (_m *MockNakamaModule) UsersGetId(ctx context.Context, userIDs []string, fa return r0, r1 } +// MockNakamaModule_UsersGetId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersGetId' +type MockNakamaModule_UsersGetId_Call struct { + *mock.Call +} + +// UsersGetId is a helper method to define mock.On call +// - ctx context.Context +// - userIDs []string +// - facebookIDs []string +func (_e *MockNakamaModule_Expecter) UsersGetId(ctx interface{}, userIDs interface{}, facebookIDs interface{}) *MockNakamaModule_UsersGetId_Call { + return &MockNakamaModule_UsersGetId_Call{Call: _e.mock.On("UsersGetId", ctx, userIDs, facebookIDs)} +} + +func (_c *MockNakamaModule_UsersGetId_Call) Run(run func(ctx context.Context, userIDs []string, facebookIDs []string)) *MockNakamaModule_UsersGetId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string), args[2].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersGetId_Call) Return(_a0 []*api.User, _a1 error) *MockNakamaModule_UsersGetId_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_UsersGetId_Call) RunAndReturn(run func(context.Context, []string, []string) ([]*api.User, error)) *MockNakamaModule_UsersGetId_Call { + _c.Call.Return(run) + return _c +} + // UsersGetRandom provides a mock function with given fields: ctx, count func (_m *MockNakamaModule) UsersGetRandom(ctx context.Context, count int) ([]*api.User, error) { ret := _m.Called(ctx, count) + if len(ret) == 0 { + panic("no return value specified for UsersGetRandom") + } + var r0 []*api.User var r1 error if rf, ok := ret.Get(0).(func(context.Context, int) ([]*api.User, error)); ok { @@ -2795,10 +7735,43 @@ func (_m *MockNakamaModule) UsersGetRandom(ctx context.Context, count int) ([]*a return r0, r1 } +// MockNakamaModule_UsersGetRandom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersGetRandom' +type MockNakamaModule_UsersGetRandom_Call struct { + *mock.Call +} + +// UsersGetRandom is a helper method to define mock.On call +// - ctx context.Context +// - count int +func (_e *MockNakamaModule_Expecter) UsersGetRandom(ctx interface{}, count interface{}) *MockNakamaModule_UsersGetRandom_Call { + return &MockNakamaModule_UsersGetRandom_Call{Call: _e.mock.On("UsersGetRandom", ctx, count)} +} + +func (_c *MockNakamaModule_UsersGetRandom_Call) Run(run func(ctx context.Context, count int)) *MockNakamaModule_UsersGetRandom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersGetRandom_Call) Return(_a0 []*api.User, _a1 error) *MockNakamaModule_UsersGetRandom_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_UsersGetRandom_Call) RunAndReturn(run func(context.Context, int) ([]*api.User, error)) *MockNakamaModule_UsersGetRandom_Call { + _c.Call.Return(run) + return _c +} + // UsersGetUsername provides a mock function with given fields: ctx, usernames func (_m *MockNakamaModule) UsersGetUsername(ctx context.Context, usernames []string) ([]*api.User, error) { ret := _m.Called(ctx, usernames) + if len(ret) == 0 { + panic("no return value specified for UsersGetUsername") + } + var r0 []*api.User var r1 error if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*api.User, error)); ok { @@ -2821,10 +7794,43 @@ func (_m *MockNakamaModule) UsersGetUsername(ctx context.Context, usernames []st return r0, r1 } +// MockNakamaModule_UsersGetUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersGetUsername' +type MockNakamaModule_UsersGetUsername_Call struct { + *mock.Call +} + +// UsersGetUsername is a helper method to define mock.On call +// - ctx context.Context +// - usernames []string +func (_e *MockNakamaModule_Expecter) UsersGetUsername(ctx interface{}, usernames interface{}) *MockNakamaModule_UsersGetUsername_Call { + return &MockNakamaModule_UsersGetUsername_Call{Call: _e.mock.On("UsersGetUsername", ctx, usernames)} +} + +func (_c *MockNakamaModule_UsersGetUsername_Call) Run(run func(ctx context.Context, usernames []string)) *MockNakamaModule_UsersGetUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersGetUsername_Call) Return(_a0 []*api.User, _a1 error) *MockNakamaModule_UsersGetUsername_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_UsersGetUsername_Call) RunAndReturn(run func(context.Context, []string) ([]*api.User, error)) *MockNakamaModule_UsersGetUsername_Call { + _c.Call.Return(run) + return _c +} + // UsersUnbanId provides a mock function with given fields: ctx, userIDs func (_m *MockNakamaModule) UsersUnbanId(ctx context.Context, userIDs []string) error { ret := _m.Called(ctx, userIDs) + if len(ret) == 0 { + panic("no return value specified for UsersUnbanId") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, []string) error); ok { r0 = rf(ctx, userIDs) @@ -2835,10 +7841,43 @@ func (_m *MockNakamaModule) UsersUnbanId(ctx context.Context, userIDs []string) return r0 } +// MockNakamaModule_UsersUnbanId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UsersUnbanId' +type MockNakamaModule_UsersUnbanId_Call struct { + *mock.Call +} + +// UsersUnbanId is a helper method to define mock.On call +// - ctx context.Context +// - userIDs []string +func (_e *MockNakamaModule_Expecter) UsersUnbanId(ctx interface{}, userIDs interface{}) *MockNakamaModule_UsersUnbanId_Call { + return &MockNakamaModule_UsersUnbanId_Call{Call: _e.mock.On("UsersUnbanId", ctx, userIDs)} +} + +func (_c *MockNakamaModule_UsersUnbanId_Call) Run(run func(ctx context.Context, userIDs []string)) *MockNakamaModule_UsersUnbanId_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockNakamaModule_UsersUnbanId_Call) Return(_a0 error) *MockNakamaModule_UsersUnbanId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockNakamaModule_UsersUnbanId_Call) RunAndReturn(run func(context.Context, []string) error) *MockNakamaModule_UsersUnbanId_Call { + _c.Call.Return(run) + return _c +} + // WalletLedgerList provides a mock function with given fields: ctx, userID, limit, cursor func (_m *MockNakamaModule) WalletLedgerList(ctx context.Context, userID string, limit int, cursor string) ([]runtime.WalletLedgerItem, string, error) { ret := _m.Called(ctx, userID, limit, cursor) + if len(ret) == 0 { + panic("no return value specified for WalletLedgerList") + } + var r0 []runtime.WalletLedgerItem var r1 string var r2 error @@ -2868,10 +7907,45 @@ func (_m *MockNakamaModule) WalletLedgerList(ctx context.Context, userID string, return r0, r1, r2 } +// MockNakamaModule_WalletLedgerList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WalletLedgerList' +type MockNakamaModule_WalletLedgerList_Call struct { + *mock.Call +} + +// WalletLedgerList is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - limit int +// - cursor string +func (_e *MockNakamaModule_Expecter) WalletLedgerList(ctx interface{}, userID interface{}, limit interface{}, cursor interface{}) *MockNakamaModule_WalletLedgerList_Call { + return &MockNakamaModule_WalletLedgerList_Call{Call: _e.mock.On("WalletLedgerList", ctx, userID, limit, cursor)} +} + +func (_c *MockNakamaModule_WalletLedgerList_Call) Run(run func(ctx context.Context, userID string, limit int, cursor string)) *MockNakamaModule_WalletLedgerList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(string)) + }) + return _c +} + +func (_c *MockNakamaModule_WalletLedgerList_Call) Return(_a0 []runtime.WalletLedgerItem, _a1 string, _a2 error) *MockNakamaModule_WalletLedgerList_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockNakamaModule_WalletLedgerList_Call) RunAndReturn(run func(context.Context, string, int, string) ([]runtime.WalletLedgerItem, string, error)) *MockNakamaModule_WalletLedgerList_Call { + _c.Call.Return(run) + return _c +} + // WalletLedgerUpdate provides a mock function with given fields: ctx, itemID, metadata func (_m *MockNakamaModule) WalletLedgerUpdate(ctx context.Context, itemID string, metadata map[string]interface{}) (runtime.WalletLedgerItem, error) { ret := _m.Called(ctx, itemID, metadata) + if len(ret) == 0 { + panic("no return value specified for WalletLedgerUpdate") + } + var r0 runtime.WalletLedgerItem var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, map[string]interface{}) (runtime.WalletLedgerItem, error)); ok { @@ -2894,10 +7968,44 @@ func (_m *MockNakamaModule) WalletLedgerUpdate(ctx context.Context, itemID strin return r0, r1 } +// MockNakamaModule_WalletLedgerUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WalletLedgerUpdate' +type MockNakamaModule_WalletLedgerUpdate_Call struct { + *mock.Call +} + +// WalletLedgerUpdate is a helper method to define mock.On call +// - ctx context.Context +// - itemID string +// - metadata map[string]interface{} +func (_e *MockNakamaModule_Expecter) WalletLedgerUpdate(ctx interface{}, itemID interface{}, metadata interface{}) *MockNakamaModule_WalletLedgerUpdate_Call { + return &MockNakamaModule_WalletLedgerUpdate_Call{Call: _e.mock.On("WalletLedgerUpdate", ctx, itemID, metadata)} +} + +func (_c *MockNakamaModule_WalletLedgerUpdate_Call) Run(run func(ctx context.Context, itemID string, metadata map[string]interface{})) *MockNakamaModule_WalletLedgerUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]interface{})) + }) + return _c +} + +func (_c *MockNakamaModule_WalletLedgerUpdate_Call) Return(_a0 runtime.WalletLedgerItem, _a1 error) *MockNakamaModule_WalletLedgerUpdate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_WalletLedgerUpdate_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}) (runtime.WalletLedgerItem, error)) *MockNakamaModule_WalletLedgerUpdate_Call { + _c.Call.Return(run) + return _c +} + // WalletUpdate provides a mock function with given fields: ctx, userID, changeset, metadata, updateLedger func (_m *MockNakamaModule) WalletUpdate(ctx context.Context, userID string, changeset map[string]int64, metadata map[string]interface{}, updateLedger bool) (map[string]int64, map[string]int64, error) { ret := _m.Called(ctx, userID, changeset, metadata, updateLedger) + if len(ret) == 0 { + panic("no return value specified for WalletUpdate") + } + var r0 map[string]int64 var r1 map[string]int64 var r2 error @@ -2929,10 +8037,46 @@ func (_m *MockNakamaModule) WalletUpdate(ctx context.Context, userID string, cha return r0, r1, r2 } +// MockNakamaModule_WalletUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WalletUpdate' +type MockNakamaModule_WalletUpdate_Call struct { + *mock.Call +} + +// WalletUpdate is a helper method to define mock.On call +// - ctx context.Context +// - userID string +// - changeset map[string]int64 +// - metadata map[string]interface{} +// - updateLedger bool +func (_e *MockNakamaModule_Expecter) WalletUpdate(ctx interface{}, userID interface{}, changeset interface{}, metadata interface{}, updateLedger interface{}) *MockNakamaModule_WalletUpdate_Call { + return &MockNakamaModule_WalletUpdate_Call{Call: _e.mock.On("WalletUpdate", ctx, userID, changeset, metadata, updateLedger)} +} + +func (_c *MockNakamaModule_WalletUpdate_Call) Run(run func(ctx context.Context, userID string, changeset map[string]int64, metadata map[string]interface{}, updateLedger bool)) *MockNakamaModule_WalletUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(map[string]int64), args[3].(map[string]interface{}), args[4].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_WalletUpdate_Call) Return(updated map[string]int64, previous map[string]int64, err error) *MockNakamaModule_WalletUpdate_Call { + _c.Call.Return(updated, previous, err) + return _c +} + +func (_c *MockNakamaModule_WalletUpdate_Call) RunAndReturn(run func(context.Context, string, map[string]int64, map[string]interface{}, bool) (map[string]int64, map[string]int64, error)) *MockNakamaModule_WalletUpdate_Call { + _c.Call.Return(run) + return _c +} + // WalletsUpdate provides a mock function with given fields: ctx, updates, updateLedger func (_m *MockNakamaModule) WalletsUpdate(ctx context.Context, updates []*runtime.WalletUpdate, updateLedger bool) ([]*runtime.WalletUpdateResult, error) { ret := _m.Called(ctx, updates, updateLedger) + if len(ret) == 0 { + panic("no return value specified for WalletsUpdate") + } + var r0 []*runtime.WalletUpdateResult var r1 error if rf, ok := ret.Get(0).(func(context.Context, []*runtime.WalletUpdate, bool) ([]*runtime.WalletUpdateResult, error)); ok { @@ -2955,13 +8099,42 @@ func (_m *MockNakamaModule) WalletsUpdate(ctx context.Context, updates []*runtim return r0, r1 } -type mockConstructorTestingTNewMockNakamaModule interface { - mock.TestingT - Cleanup(func()) +// MockNakamaModule_WalletsUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WalletsUpdate' +type MockNakamaModule_WalletsUpdate_Call struct { + *mock.Call +} + +// WalletsUpdate is a helper method to define mock.On call +// - ctx context.Context +// - updates []*runtime.WalletUpdate +// - updateLedger bool +func (_e *MockNakamaModule_Expecter) WalletsUpdate(ctx interface{}, updates interface{}, updateLedger interface{}) *MockNakamaModule_WalletsUpdate_Call { + return &MockNakamaModule_WalletsUpdate_Call{Call: _e.mock.On("WalletsUpdate", ctx, updates, updateLedger)} +} + +func (_c *MockNakamaModule_WalletsUpdate_Call) Run(run func(ctx context.Context, updates []*runtime.WalletUpdate, updateLedger bool)) *MockNakamaModule_WalletsUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]*runtime.WalletUpdate), args[2].(bool)) + }) + return _c +} + +func (_c *MockNakamaModule_WalletsUpdate_Call) Return(_a0 []*runtime.WalletUpdateResult, _a1 error) *MockNakamaModule_WalletsUpdate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockNakamaModule_WalletsUpdate_Call) RunAndReturn(run func(context.Context, []*runtime.WalletUpdate, bool) ([]*runtime.WalletUpdateResult, error)) *MockNakamaModule_WalletsUpdate_Call { + _c.Call.Return(run) + return _c } // NewMockNakamaModule creates a new instance of MockNakamaModule. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockNakamaModule(t mockConstructorTestingTNewMockNakamaModule) *MockNakamaModule { +// The first argument is typically a *testing.T value. +func NewMockNakamaModule(t interface { + mock.TestingT + Cleanup(func()) +}) *MockNakamaModule { mock := &MockNakamaModule{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_Presence.go b/relay/nakama/mocks/mock_Presence.go index 4c0a02ad3..cca5b119d 100644 --- a/relay/nakama/mocks/mock_Presence.go +++ b/relay/nakama/mocks/mock_Presence.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockPresence struct { mock.Mock } -// GetHidden provides a mock function with given fields: +type MockPresence_Expecter struct { + mock *mock.Mock +} + +func (_m *MockPresence) EXPECT() *MockPresence_Expecter { + return &MockPresence_Expecter{mock: &_m.Mock} +} + +// GetHidden provides a mock function with no fields func (_m *MockPresence) GetHidden() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetHidden") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -26,10 +38,41 @@ func (_m *MockPresence) GetHidden() bool { return r0 } -// GetNodeId provides a mock function with given fields: +// MockPresence_GetHidden_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHidden' +type MockPresence_GetHidden_Call struct { + *mock.Call +} + +// GetHidden is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetHidden() *MockPresence_GetHidden_Call { + return &MockPresence_GetHidden_Call{Call: _e.mock.On("GetHidden")} +} + +func (_c *MockPresence_GetHidden_Call) Run(run func()) *MockPresence_GetHidden_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetHidden_Call) Return(_a0 bool) *MockPresence_GetHidden_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetHidden_Call) RunAndReturn(run func() bool) *MockPresence_GetHidden_Call { + _c.Call.Return(run) + return _c +} + +// GetNodeId provides a mock function with no fields func (_m *MockPresence) GetNodeId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetNodeId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -40,10 +83,41 @@ func (_m *MockPresence) GetNodeId() string { return r0 } -// GetPersistence provides a mock function with given fields: +// MockPresence_GetNodeId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeId' +type MockPresence_GetNodeId_Call struct { + *mock.Call +} + +// GetNodeId is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetNodeId() *MockPresence_GetNodeId_Call { + return &MockPresence_GetNodeId_Call{Call: _e.mock.On("GetNodeId")} +} + +func (_c *MockPresence_GetNodeId_Call) Run(run func()) *MockPresence_GetNodeId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetNodeId_Call) Return(_a0 string) *MockPresence_GetNodeId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetNodeId_Call) RunAndReturn(run func() string) *MockPresence_GetNodeId_Call { + _c.Call.Return(run) + return _c +} + +// GetPersistence provides a mock function with no fields func (_m *MockPresence) GetPersistence() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetPersistence") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -54,10 +128,41 @@ func (_m *MockPresence) GetPersistence() bool { return r0 } -// GetReason provides a mock function with given fields: +// MockPresence_GetPersistence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPersistence' +type MockPresence_GetPersistence_Call struct { + *mock.Call +} + +// GetPersistence is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetPersistence() *MockPresence_GetPersistence_Call { + return &MockPresence_GetPersistence_Call{Call: _e.mock.On("GetPersistence")} +} + +func (_c *MockPresence_GetPersistence_Call) Run(run func()) *MockPresence_GetPersistence_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetPersistence_Call) Return(_a0 bool) *MockPresence_GetPersistence_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetPersistence_Call) RunAndReturn(run func() bool) *MockPresence_GetPersistence_Call { + _c.Call.Return(run) + return _c +} + +// GetReason provides a mock function with no fields func (_m *MockPresence) GetReason() runtime.PresenceReason { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetReason") + } + var r0 runtime.PresenceReason if rf, ok := ret.Get(0).(func() runtime.PresenceReason); ok { r0 = rf() @@ -68,10 +173,41 @@ func (_m *MockPresence) GetReason() runtime.PresenceReason { return r0 } -// GetSessionId provides a mock function with given fields: +// MockPresence_GetReason_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReason' +type MockPresence_GetReason_Call struct { + *mock.Call +} + +// GetReason is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetReason() *MockPresence_GetReason_Call { + return &MockPresence_GetReason_Call{Call: _e.mock.On("GetReason")} +} + +func (_c *MockPresence_GetReason_Call) Run(run func()) *MockPresence_GetReason_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetReason_Call) Return(_a0 runtime.PresenceReason) *MockPresence_GetReason_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetReason_Call) RunAndReturn(run func() runtime.PresenceReason) *MockPresence_GetReason_Call { + _c.Call.Return(run) + return _c +} + +// GetSessionId provides a mock function with no fields func (_m *MockPresence) GetSessionId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetSessionId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -82,10 +218,41 @@ func (_m *MockPresence) GetSessionId() string { return r0 } -// GetStatus provides a mock function with given fields: +// MockPresence_GetSessionId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionId' +type MockPresence_GetSessionId_Call struct { + *mock.Call +} + +// GetSessionId is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetSessionId() *MockPresence_GetSessionId_Call { + return &MockPresence_GetSessionId_Call{Call: _e.mock.On("GetSessionId")} +} + +func (_c *MockPresence_GetSessionId_Call) Run(run func()) *MockPresence_GetSessionId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetSessionId_Call) Return(_a0 string) *MockPresence_GetSessionId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetSessionId_Call) RunAndReturn(run func() string) *MockPresence_GetSessionId_Call { + _c.Call.Return(run) + return _c +} + +// GetStatus provides a mock function with no fields func (_m *MockPresence) GetStatus() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetStatus") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -96,10 +263,41 @@ func (_m *MockPresence) GetStatus() string { return r0 } -// GetUserId provides a mock function with given fields: +// MockPresence_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus' +type MockPresence_GetStatus_Call struct { + *mock.Call +} + +// GetStatus is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetStatus() *MockPresence_GetStatus_Call { + return &MockPresence_GetStatus_Call{Call: _e.mock.On("GetStatus")} +} + +func (_c *MockPresence_GetStatus_Call) Run(run func()) *MockPresence_GetStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetStatus_Call) Return(_a0 string) *MockPresence_GetStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetStatus_Call) RunAndReturn(run func() string) *MockPresence_GetStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetUserId provides a mock function with no fields func (_m *MockPresence) GetUserId() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUserId") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -110,10 +308,41 @@ func (_m *MockPresence) GetUserId() string { return r0 } -// GetUsername provides a mock function with given fields: +// MockPresence_GetUserId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserId' +type MockPresence_GetUserId_Call struct { + *mock.Call +} + +// GetUserId is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetUserId() *MockPresence_GetUserId_Call { + return &MockPresence_GetUserId_Call{Call: _e.mock.On("GetUserId")} +} + +func (_c *MockPresence_GetUserId_Call) Run(run func()) *MockPresence_GetUserId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetUserId_Call) Return(_a0 string) *MockPresence_GetUserId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetUserId_Call) RunAndReturn(run func() string) *MockPresence_GetUserId_Call { + _c.Call.Return(run) + return _c +} + +// GetUsername provides a mock function with no fields func (_m *MockPresence) GetUsername() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUsername") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -124,13 +353,39 @@ func (_m *MockPresence) GetUsername() string { return r0 } -type mockConstructorTestingTNewMockPresence interface { - mock.TestingT - Cleanup(func()) +// MockPresence_GetUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsername' +type MockPresence_GetUsername_Call struct { + *mock.Call +} + +// GetUsername is a helper method to define mock.On call +func (_e *MockPresence_Expecter) GetUsername() *MockPresence_GetUsername_Call { + return &MockPresence_GetUsername_Call{Call: _e.mock.On("GetUsername")} +} + +func (_c *MockPresence_GetUsername_Call) Run(run func()) *MockPresence_GetUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresence_GetUsername_Call) Return(_a0 string) *MockPresence_GetUsername_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresence_GetUsername_Call) RunAndReturn(run func() string) *MockPresence_GetUsername_Call { + _c.Call.Return(run) + return _c } // NewMockPresence creates a new instance of MockPresence. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockPresence(t mockConstructorTestingTNewMockPresence) *MockPresence { +// The first argument is typically a *testing.T value. +func NewMockPresence(t interface { + mock.TestingT + Cleanup(func()) +}) *MockPresence { mock := &MockPresence{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_PresenceMeta.go b/relay/nakama/mocks/mock_PresenceMeta.go index 3b143f5ed..4358386bd 100644 --- a/relay/nakama/mocks/mock_PresenceMeta.go +++ b/relay/nakama/mocks/mock_PresenceMeta.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -12,10 +12,22 @@ type MockPresenceMeta struct { mock.Mock } -// GetHidden provides a mock function with given fields: +type MockPresenceMeta_Expecter struct { + mock *mock.Mock +} + +func (_m *MockPresenceMeta) EXPECT() *MockPresenceMeta_Expecter { + return &MockPresenceMeta_Expecter{mock: &_m.Mock} +} + +// GetHidden provides a mock function with no fields func (_m *MockPresenceMeta) GetHidden() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetHidden") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -26,10 +38,41 @@ func (_m *MockPresenceMeta) GetHidden() bool { return r0 } -// GetPersistence provides a mock function with given fields: +// MockPresenceMeta_GetHidden_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHidden' +type MockPresenceMeta_GetHidden_Call struct { + *mock.Call +} + +// GetHidden is a helper method to define mock.On call +func (_e *MockPresenceMeta_Expecter) GetHidden() *MockPresenceMeta_GetHidden_Call { + return &MockPresenceMeta_GetHidden_Call{Call: _e.mock.On("GetHidden")} +} + +func (_c *MockPresenceMeta_GetHidden_Call) Run(run func()) *MockPresenceMeta_GetHidden_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresenceMeta_GetHidden_Call) Return(_a0 bool) *MockPresenceMeta_GetHidden_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresenceMeta_GetHidden_Call) RunAndReturn(run func() bool) *MockPresenceMeta_GetHidden_Call { + _c.Call.Return(run) + return _c +} + +// GetPersistence provides a mock function with no fields func (_m *MockPresenceMeta) GetPersistence() bool { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetPersistence") + } + var r0 bool if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() @@ -40,10 +83,41 @@ func (_m *MockPresenceMeta) GetPersistence() bool { return r0 } -// GetReason provides a mock function with given fields: +// MockPresenceMeta_GetPersistence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPersistence' +type MockPresenceMeta_GetPersistence_Call struct { + *mock.Call +} + +// GetPersistence is a helper method to define mock.On call +func (_e *MockPresenceMeta_Expecter) GetPersistence() *MockPresenceMeta_GetPersistence_Call { + return &MockPresenceMeta_GetPersistence_Call{Call: _e.mock.On("GetPersistence")} +} + +func (_c *MockPresenceMeta_GetPersistence_Call) Run(run func()) *MockPresenceMeta_GetPersistence_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresenceMeta_GetPersistence_Call) Return(_a0 bool) *MockPresenceMeta_GetPersistence_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresenceMeta_GetPersistence_Call) RunAndReturn(run func() bool) *MockPresenceMeta_GetPersistence_Call { + _c.Call.Return(run) + return _c +} + +// GetReason provides a mock function with no fields func (_m *MockPresenceMeta) GetReason() runtime.PresenceReason { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetReason") + } + var r0 runtime.PresenceReason if rf, ok := ret.Get(0).(func() runtime.PresenceReason); ok { r0 = rf() @@ -54,10 +128,41 @@ func (_m *MockPresenceMeta) GetReason() runtime.PresenceReason { return r0 } -// GetStatus provides a mock function with given fields: +// MockPresenceMeta_GetReason_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReason' +type MockPresenceMeta_GetReason_Call struct { + *mock.Call +} + +// GetReason is a helper method to define mock.On call +func (_e *MockPresenceMeta_Expecter) GetReason() *MockPresenceMeta_GetReason_Call { + return &MockPresenceMeta_GetReason_Call{Call: _e.mock.On("GetReason")} +} + +func (_c *MockPresenceMeta_GetReason_Call) Run(run func()) *MockPresenceMeta_GetReason_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresenceMeta_GetReason_Call) Return(_a0 runtime.PresenceReason) *MockPresenceMeta_GetReason_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresenceMeta_GetReason_Call) RunAndReturn(run func() runtime.PresenceReason) *MockPresenceMeta_GetReason_Call { + _c.Call.Return(run) + return _c +} + +// GetStatus provides a mock function with no fields func (_m *MockPresenceMeta) GetStatus() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetStatus") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -68,10 +173,41 @@ func (_m *MockPresenceMeta) GetStatus() string { return r0 } -// GetUsername provides a mock function with given fields: +// MockPresenceMeta_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus' +type MockPresenceMeta_GetStatus_Call struct { + *mock.Call +} + +// GetStatus is a helper method to define mock.On call +func (_e *MockPresenceMeta_Expecter) GetStatus() *MockPresenceMeta_GetStatus_Call { + return &MockPresenceMeta_GetStatus_Call{Call: _e.mock.On("GetStatus")} +} + +func (_c *MockPresenceMeta_GetStatus_Call) Run(run func()) *MockPresenceMeta_GetStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresenceMeta_GetStatus_Call) Return(_a0 string) *MockPresenceMeta_GetStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresenceMeta_GetStatus_Call) RunAndReturn(run func() string) *MockPresenceMeta_GetStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetUsername provides a mock function with no fields func (_m *MockPresenceMeta) GetUsername() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUsername") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -82,13 +218,39 @@ func (_m *MockPresenceMeta) GetUsername() string { return r0 } -type mockConstructorTestingTNewMockPresenceMeta interface { - mock.TestingT - Cleanup(func()) +// MockPresenceMeta_GetUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsername' +type MockPresenceMeta_GetUsername_Call struct { + *mock.Call +} + +// GetUsername is a helper method to define mock.On call +func (_e *MockPresenceMeta_Expecter) GetUsername() *MockPresenceMeta_GetUsername_Call { + return &MockPresenceMeta_GetUsername_Call{Call: _e.mock.On("GetUsername")} +} + +func (_c *MockPresenceMeta_GetUsername_Call) Run(run func()) *MockPresenceMeta_GetUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPresenceMeta_GetUsername_Call) Return(_a0 string) *MockPresenceMeta_GetUsername_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPresenceMeta_GetUsername_Call) RunAndReturn(run func() string) *MockPresenceMeta_GetUsername_Call { + _c.Call.Return(run) + return _c } // NewMockPresenceMeta creates a new instance of MockPresenceMeta. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockPresenceMeta(t mockConstructorTestingTNewMockPresenceMeta) *MockPresenceMeta { +// The first argument is typically a *testing.T value. +func NewMockPresenceMeta(t interface { + mock.TestingT + Cleanup(func()) +}) *MockPresenceMeta { mock := &MockPresenceMeta{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_RuntimeConfig.go b/relay/nakama/mocks/mock_RuntimeConfig.go new file mode 100644 index 000000000..840c74d16 --- /dev/null +++ b/relay/nakama/mocks/mock_RuntimeConfig.go @@ -0,0 +1,124 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockRuntimeConfig is an autogenerated mock type for the RuntimeConfig type +type MockRuntimeConfig struct { + mock.Mock +} + +type MockRuntimeConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRuntimeConfig) EXPECT() *MockRuntimeConfig_Expecter { + return &MockRuntimeConfig_Expecter{mock: &_m.Mock} +} + +// GetEnv provides a mock function with no fields +func (_m *MockRuntimeConfig) GetEnv() []string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetEnv") + } + + var r0 []string + if rf, ok := ret.Get(0).(func() []string); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + return r0 +} + +// MockRuntimeConfig_GetEnv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnv' +type MockRuntimeConfig_GetEnv_Call struct { + *mock.Call +} + +// GetEnv is a helper method to define mock.On call +func (_e *MockRuntimeConfig_Expecter) GetEnv() *MockRuntimeConfig_GetEnv_Call { + return &MockRuntimeConfig_GetEnv_Call{Call: _e.mock.On("GetEnv")} +} + +func (_c *MockRuntimeConfig_GetEnv_Call) Run(run func()) *MockRuntimeConfig_GetEnv_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockRuntimeConfig_GetEnv_Call) Return(_a0 []string) *MockRuntimeConfig_GetEnv_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockRuntimeConfig_GetEnv_Call) RunAndReturn(run func() []string) *MockRuntimeConfig_GetEnv_Call { + _c.Call.Return(run) + return _c +} + +// GetHTTPKey provides a mock function with no fields +func (_m *MockRuntimeConfig) GetHTTPKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetHTTPKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockRuntimeConfig_GetHTTPKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHTTPKey' +type MockRuntimeConfig_GetHTTPKey_Call struct { + *mock.Call +} + +// GetHTTPKey is a helper method to define mock.On call +func (_e *MockRuntimeConfig_Expecter) GetHTTPKey() *MockRuntimeConfig_GetHTTPKey_Call { + return &MockRuntimeConfig_GetHTTPKey_Call{Call: _e.mock.On("GetHTTPKey")} +} + +func (_c *MockRuntimeConfig_GetHTTPKey_Call) Run(run func()) *MockRuntimeConfig_GetHTTPKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockRuntimeConfig_GetHTTPKey_Call) Return(_a0 string) *MockRuntimeConfig_GetHTTPKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockRuntimeConfig_GetHTTPKey_Call) RunAndReturn(run func() string) *MockRuntimeConfig_GetHTTPKey_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRuntimeConfig creates a new instance of MockRuntimeConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRuntimeConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockRuntimeConfig { + mock := &MockRuntimeConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_Satori.go b/relay/nakama/mocks/mock_Satori.go index 827919e5b..6479d509f 100644 --- a/relay/nakama/mocks/mock_Satori.go +++ b/relay/nakama/mocks/mock_Satori.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -14,20 +14,32 @@ type MockSatori struct { mock.Mock } -// Authenticate provides a mock function with given fields: ctx, id, ipAddress -func (_m *MockSatori) Authenticate(ctx context.Context, id string, ipAddress ...string) error { +type MockSatori_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSatori) EXPECT() *MockSatori_Expecter { + return &MockSatori_Expecter{mock: &_m.Mock} +} + +// Authenticate provides a mock function with given fields: ctx, id, defaultProperties, customProperties, ipAddress +func (_m *MockSatori) Authenticate(ctx context.Context, id string, defaultProperties map[string]string, customProperties map[string]string, ipAddress ...string) error { _va := make([]interface{}, len(ipAddress)) for _i := range ipAddress { _va[_i] = ipAddress[_i] } var _ca []interface{} - _ca = append(_ca, ctx, id) + _ca = append(_ca, ctx, id, defaultProperties, customProperties) _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for Authenticate") + } + var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, ...string) error); ok { - r0 = rf(ctx, id, ipAddress...) + if rf, ok := ret.Get(0).(func(context.Context, string, map[string]string, map[string]string, ...string) error); ok { + r0 = rf(ctx, id, defaultProperties, customProperties, ipAddress...) } else { r0 = ret.Error(0) } @@ -35,10 +47,53 @@ func (_m *MockSatori) Authenticate(ctx context.Context, id string, ipAddress ... return r0 } +// MockSatori_Authenticate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authenticate' +type MockSatori_Authenticate_Call struct { + *mock.Call +} + +// Authenticate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - defaultProperties map[string]string +// - customProperties map[string]string +// - ipAddress ...string +func (_e *MockSatori_Expecter) Authenticate(ctx interface{}, id interface{}, defaultProperties interface{}, customProperties interface{}, ipAddress ...interface{}) *MockSatori_Authenticate_Call { + return &MockSatori_Authenticate_Call{Call: _e.mock.On("Authenticate", + append([]interface{}{ctx, id, defaultProperties, customProperties}, ipAddress...)...)} +} + +func (_c *MockSatori_Authenticate_Call) Run(run func(ctx context.Context, id string, defaultProperties map[string]string, customProperties map[string]string, ipAddress ...string)) *MockSatori_Authenticate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(map[string]string), args[3].(map[string]string), variadicArgs...) + }) + return _c +} + +func (_c *MockSatori_Authenticate_Call) Return(_a0 error) *MockSatori_Authenticate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatori_Authenticate_Call) RunAndReturn(run func(context.Context, string, map[string]string, map[string]string, ...string) error) *MockSatori_Authenticate_Call { + _c.Call.Return(run) + return _c +} + // EventsPublish provides a mock function with given fields: ctx, id, events func (_m *MockSatori) EventsPublish(ctx context.Context, id string, events []*runtime.Event) error { ret := _m.Called(ctx, id, events) + if len(ret) == 0 { + panic("no return value specified for EventsPublish") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, []*runtime.Event) error); ok { r0 = rf(ctx, id, events) @@ -49,6 +104,36 @@ func (_m *MockSatori) EventsPublish(ctx context.Context, id string, events []*ru return r0 } +// MockSatori_EventsPublish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsPublish' +type MockSatori_EventsPublish_Call struct { + *mock.Call +} + +// EventsPublish is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - events []*runtime.Event +func (_e *MockSatori_Expecter) EventsPublish(ctx interface{}, id interface{}, events interface{}) *MockSatori_EventsPublish_Call { + return &MockSatori_EventsPublish_Call{Call: _e.mock.On("EventsPublish", ctx, id, events)} +} + +func (_c *MockSatori_EventsPublish_Call) Run(run func(ctx context.Context, id string, events []*runtime.Event)) *MockSatori_EventsPublish_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]*runtime.Event)) + }) + return _c +} + +func (_c *MockSatori_EventsPublish_Call) Return(_a0 error) *MockSatori_EventsPublish_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatori_EventsPublish_Call) RunAndReturn(run func(context.Context, string, []*runtime.Event) error) *MockSatori_EventsPublish_Call { + _c.Call.Return(run) + return _c +} + // ExperimentsList provides a mock function with given fields: ctx, id, names func (_m *MockSatori) ExperimentsList(ctx context.Context, id string, names ...string) (*runtime.ExperimentList, error) { _va := make([]interface{}, len(names)) @@ -60,6 +145,10 @@ func (_m *MockSatori) ExperimentsList(ctx context.Context, id string, names ...s _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for ExperimentsList") + } + var r0 *runtime.ExperimentList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.ExperimentList, error)); ok { @@ -82,6 +171,43 @@ func (_m *MockSatori) ExperimentsList(ctx context.Context, id string, names ...s return r0, r1 } +// MockSatori_ExperimentsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExperimentsList' +type MockSatori_ExperimentsList_Call struct { + *mock.Call +} + +// ExperimentsList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - names ...string +func (_e *MockSatori_Expecter) ExperimentsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_ExperimentsList_Call { + return &MockSatori_ExperimentsList_Call{Call: _e.mock.On("ExperimentsList", + append([]interface{}{ctx, id}, names...)...)} +} + +func (_c *MockSatori_ExperimentsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_ExperimentsList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockSatori_ExperimentsList_Call) Return(_a0 *runtime.ExperimentList, _a1 error) *MockSatori_ExperimentsList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSatori_ExperimentsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.ExperimentList, error)) *MockSatori_ExperimentsList_Call { + _c.Call.Return(run) + return _c +} + // FlagsList provides a mock function with given fields: ctx, id, names func (_m *MockSatori) FlagsList(ctx context.Context, id string, names ...string) (*runtime.FlagList, error) { _va := make([]interface{}, len(names)) @@ -93,6 +219,10 @@ func (_m *MockSatori) FlagsList(ctx context.Context, id string, names ...string) _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for FlagsList") + } + var r0 *runtime.FlagList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.FlagList, error)); ok { @@ -115,6 +245,43 @@ func (_m *MockSatori) FlagsList(ctx context.Context, id string, names ...string) return r0, r1 } +// MockSatori_FlagsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlagsList' +type MockSatori_FlagsList_Call struct { + *mock.Call +} + +// FlagsList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - names ...string +func (_e *MockSatori_Expecter) FlagsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_FlagsList_Call { + return &MockSatori_FlagsList_Call{Call: _e.mock.On("FlagsList", + append([]interface{}{ctx, id}, names...)...)} +} + +func (_c *MockSatori_FlagsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_FlagsList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockSatori_FlagsList_Call) Return(_a0 *runtime.FlagList, _a1 error) *MockSatori_FlagsList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSatori_FlagsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.FlagList, error)) *MockSatori_FlagsList_Call { + _c.Call.Return(run) + return _c +} + // LiveEventsList provides a mock function with given fields: ctx, id, names func (_m *MockSatori) LiveEventsList(ctx context.Context, id string, names ...string) (*runtime.LiveEventList, error) { _va := make([]interface{}, len(names)) @@ -126,6 +293,10 @@ func (_m *MockSatori) LiveEventsList(ctx context.Context, id string, names ...st _ca = append(_ca, _va...) ret := _m.Called(_ca...) + if len(ret) == 0 { + panic("no return value specified for LiveEventsList") + } + var r0 *runtime.LiveEventList var r1 error if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.LiveEventList, error)); ok { @@ -148,10 +319,211 @@ func (_m *MockSatori) LiveEventsList(ctx context.Context, id string, names ...st return r0, r1 } +// MockSatori_LiveEventsList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LiveEventsList' +type MockSatori_LiveEventsList_Call struct { + *mock.Call +} + +// LiveEventsList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - names ...string +func (_e *MockSatori_Expecter) LiveEventsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_LiveEventsList_Call { + return &MockSatori_LiveEventsList_Call{Call: _e.mock.On("LiveEventsList", + append([]interface{}{ctx, id}, names...)...)} +} + +func (_c *MockSatori_LiveEventsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_LiveEventsList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockSatori_LiveEventsList_Call) Return(_a0 *runtime.LiveEventList, _a1 error) *MockSatori_LiveEventsList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSatori_LiveEventsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.LiveEventList, error)) *MockSatori_LiveEventsList_Call { + _c.Call.Return(run) + return _c +} + +// MessageDelete provides a mock function with given fields: ctx, id, messageId +func (_m *MockSatori) MessageDelete(ctx context.Context, id string, messageId string) error { + ret := _m.Called(ctx, id, messageId) + + if len(ret) == 0 { + panic("no return value specified for MessageDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, id, messageId) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSatori_MessageDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessageDelete' +type MockSatori_MessageDelete_Call struct { + *mock.Call +} + +// MessageDelete is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - messageId string +func (_e *MockSatori_Expecter) MessageDelete(ctx interface{}, id interface{}, messageId interface{}) *MockSatori_MessageDelete_Call { + return &MockSatori_MessageDelete_Call{Call: _e.mock.On("MessageDelete", ctx, id, messageId)} +} + +func (_c *MockSatori_MessageDelete_Call) Run(run func(ctx context.Context, id string, messageId string)) *MockSatori_MessageDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockSatori_MessageDelete_Call) Return(_a0 error) *MockSatori_MessageDelete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatori_MessageDelete_Call) RunAndReturn(run func(context.Context, string, string) error) *MockSatori_MessageDelete_Call { + _c.Call.Return(run) + return _c +} + +// MessageUpdate provides a mock function with given fields: ctx, id, messageId, readTime, consumeTime +func (_m *MockSatori) MessageUpdate(ctx context.Context, id string, messageId string, readTime int64, consumeTime int64) error { + ret := _m.Called(ctx, id, messageId, readTime, consumeTime) + + if len(ret) == 0 { + panic("no return value specified for MessageUpdate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64, int64) error); ok { + r0 = rf(ctx, id, messageId, readTime, consumeTime) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSatori_MessageUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessageUpdate' +type MockSatori_MessageUpdate_Call struct { + *mock.Call +} + +// MessageUpdate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - messageId string +// - readTime int64 +// - consumeTime int64 +func (_e *MockSatori_Expecter) MessageUpdate(ctx interface{}, id interface{}, messageId interface{}, readTime interface{}, consumeTime interface{}) *MockSatori_MessageUpdate_Call { + return &MockSatori_MessageUpdate_Call{Call: _e.mock.On("MessageUpdate", ctx, id, messageId, readTime, consumeTime)} +} + +func (_c *MockSatori_MessageUpdate_Call) Run(run func(ctx context.Context, id string, messageId string, readTime int64, consumeTime int64)) *MockSatori_MessageUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), args[4].(int64)) + }) + return _c +} + +func (_c *MockSatori_MessageUpdate_Call) Return(_a0 error) *MockSatori_MessageUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatori_MessageUpdate_Call) RunAndReturn(run func(context.Context, string, string, int64, int64) error) *MockSatori_MessageUpdate_Call { + _c.Call.Return(run) + return _c +} + +// MessagesList provides a mock function with given fields: ctx, id, limit, forward, cursor +func (_m *MockSatori) MessagesList(ctx context.Context, id string, limit int, forward bool, cursor string) (*runtime.MessageList, error) { + ret := _m.Called(ctx, id, limit, forward, cursor) + + if len(ret) == 0 { + panic("no return value specified for MessagesList") + } + + var r0 *runtime.MessageList + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, int, bool, string) (*runtime.MessageList, error)); ok { + return rf(ctx, id, limit, forward, cursor) + } + if rf, ok := ret.Get(0).(func(context.Context, string, int, bool, string) *runtime.MessageList); ok { + r0 = rf(ctx, id, limit, forward, cursor) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*runtime.MessageList) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, int, bool, string) error); ok { + r1 = rf(ctx, id, limit, forward, cursor) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSatori_MessagesList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessagesList' +type MockSatori_MessagesList_Call struct { + *mock.Call +} + +// MessagesList is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - limit int +// - forward bool +// - cursor string +func (_e *MockSatori_Expecter) MessagesList(ctx interface{}, id interface{}, limit interface{}, forward interface{}, cursor interface{}) *MockSatori_MessagesList_Call { + return &MockSatori_MessagesList_Call{Call: _e.mock.On("MessagesList", ctx, id, limit, forward, cursor)} +} + +func (_c *MockSatori_MessagesList_Call) Run(run func(ctx context.Context, id string, limit int, forward bool, cursor string)) *MockSatori_MessagesList_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(bool), args[4].(string)) + }) + return _c +} + +func (_c *MockSatori_MessagesList_Call) Return(_a0 *runtime.MessageList, _a1 error) *MockSatori_MessagesList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSatori_MessagesList_Call) RunAndReturn(run func(context.Context, string, int, bool, string) (*runtime.MessageList, error)) *MockSatori_MessagesList_Call { + _c.Call.Return(run) + return _c +} + // PropertiesGet provides a mock function with given fields: ctx, id func (_m *MockSatori) PropertiesGet(ctx context.Context, id string) (*runtime.Properties, error) { ret := _m.Called(ctx, id) + if len(ret) == 0 { + panic("no return value specified for PropertiesGet") + } + var r0 *runtime.Properties var r1 error if rf, ok := ret.Get(0).(func(context.Context, string) (*runtime.Properties, error)); ok { @@ -174,10 +546,43 @@ func (_m *MockSatori) PropertiesGet(ctx context.Context, id string) (*runtime.Pr return r0, r1 } +// MockSatori_PropertiesGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PropertiesGet' +type MockSatori_PropertiesGet_Call struct { + *mock.Call +} + +// PropertiesGet is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockSatori_Expecter) PropertiesGet(ctx interface{}, id interface{}) *MockSatori_PropertiesGet_Call { + return &MockSatori_PropertiesGet_Call{Call: _e.mock.On("PropertiesGet", ctx, id)} +} + +func (_c *MockSatori_PropertiesGet_Call) Run(run func(ctx context.Context, id string)) *MockSatori_PropertiesGet_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSatori_PropertiesGet_Call) Return(_a0 *runtime.Properties, _a1 error) *MockSatori_PropertiesGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSatori_PropertiesGet_Call) RunAndReturn(run func(context.Context, string) (*runtime.Properties, error)) *MockSatori_PropertiesGet_Call { + _c.Call.Return(run) + return _c +} + // PropertiesUpdate provides a mock function with given fields: ctx, id, properties func (_m *MockSatori) PropertiesUpdate(ctx context.Context, id string, properties *runtime.PropertiesUpdate) error { ret := _m.Called(ctx, id, properties) + if len(ret) == 0 { + panic("no return value specified for PropertiesUpdate") + } + var r0 error if rf, ok := ret.Get(0).(func(context.Context, string, *runtime.PropertiesUpdate) error); ok { r0 = rf(ctx, id, properties) @@ -188,13 +593,42 @@ func (_m *MockSatori) PropertiesUpdate(ctx context.Context, id string, propertie return r0 } -type mockConstructorTestingTNewMockSatori interface { - mock.TestingT - Cleanup(func()) +// MockSatori_PropertiesUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PropertiesUpdate' +type MockSatori_PropertiesUpdate_Call struct { + *mock.Call +} + +// PropertiesUpdate is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - properties *runtime.PropertiesUpdate +func (_e *MockSatori_Expecter) PropertiesUpdate(ctx interface{}, id interface{}, properties interface{}) *MockSatori_PropertiesUpdate_Call { + return &MockSatori_PropertiesUpdate_Call{Call: _e.mock.On("PropertiesUpdate", ctx, id, properties)} +} + +func (_c *MockSatori_PropertiesUpdate_Call) Run(run func(ctx context.Context, id string, properties *runtime.PropertiesUpdate)) *MockSatori_PropertiesUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*runtime.PropertiesUpdate)) + }) + return _c +} + +func (_c *MockSatori_PropertiesUpdate_Call) Return(_a0 error) *MockSatori_PropertiesUpdate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatori_PropertiesUpdate_Call) RunAndReturn(run func(context.Context, string, *runtime.PropertiesUpdate) error) *MockSatori_PropertiesUpdate_Call { + _c.Call.Return(run) + return _c } // NewMockSatori creates a new instance of MockSatori. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockSatori(t mockConstructorTestingTNewMockSatori) *MockSatori { +// The first argument is typically a *testing.T value. +func NewMockSatori(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSatori { mock := &MockSatori{} mock.Mock.Test(t) diff --git a/relay/nakama/mocks/mock_SatoriConfig.go b/relay/nakama/mocks/mock_SatoriConfig.go new file mode 100644 index 000000000..f7f382f2e --- /dev/null +++ b/relay/nakama/mocks/mock_SatoriConfig.go @@ -0,0 +1,212 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSatoriConfig is an autogenerated mock type for the SatoriConfig type +type MockSatoriConfig struct { + mock.Mock +} + +type MockSatoriConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSatoriConfig) EXPECT() *MockSatoriConfig_Expecter { + return &MockSatoriConfig_Expecter{mock: &_m.Mock} +} + +// GetApiKey provides a mock function with no fields +func (_m *MockSatoriConfig) GetApiKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetApiKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSatoriConfig_GetApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKey' +type MockSatoriConfig_GetApiKey_Call struct { + *mock.Call +} + +// GetApiKey is a helper method to define mock.On call +func (_e *MockSatoriConfig_Expecter) GetApiKey() *MockSatoriConfig_GetApiKey_Call { + return &MockSatoriConfig_GetApiKey_Call{Call: _e.mock.On("GetApiKey")} +} + +func (_c *MockSatoriConfig_GetApiKey_Call) Run(run func()) *MockSatoriConfig_GetApiKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSatoriConfig_GetApiKey_Call) Return(_a0 string) *MockSatoriConfig_GetApiKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatoriConfig_GetApiKey_Call) RunAndReturn(run func() string) *MockSatoriConfig_GetApiKey_Call { + _c.Call.Return(run) + return _c +} + +// GetApiKeyName provides a mock function with no fields +func (_m *MockSatoriConfig) GetApiKeyName() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetApiKeyName") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSatoriConfig_GetApiKeyName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApiKeyName' +type MockSatoriConfig_GetApiKeyName_Call struct { + *mock.Call +} + +// GetApiKeyName is a helper method to define mock.On call +func (_e *MockSatoriConfig_Expecter) GetApiKeyName() *MockSatoriConfig_GetApiKeyName_Call { + return &MockSatoriConfig_GetApiKeyName_Call{Call: _e.mock.On("GetApiKeyName")} +} + +func (_c *MockSatoriConfig_GetApiKeyName_Call) Run(run func()) *MockSatoriConfig_GetApiKeyName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSatoriConfig_GetApiKeyName_Call) Return(_a0 string) *MockSatoriConfig_GetApiKeyName_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatoriConfig_GetApiKeyName_Call) RunAndReturn(run func() string) *MockSatoriConfig_GetApiKeyName_Call { + _c.Call.Return(run) + return _c +} + +// GetSigningKey provides a mock function with no fields +func (_m *MockSatoriConfig) GetSigningKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSigningKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSatoriConfig_GetSigningKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSigningKey' +type MockSatoriConfig_GetSigningKey_Call struct { + *mock.Call +} + +// GetSigningKey is a helper method to define mock.On call +func (_e *MockSatoriConfig_Expecter) GetSigningKey() *MockSatoriConfig_GetSigningKey_Call { + return &MockSatoriConfig_GetSigningKey_Call{Call: _e.mock.On("GetSigningKey")} +} + +func (_c *MockSatoriConfig_GetSigningKey_Call) Run(run func()) *MockSatoriConfig_GetSigningKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSatoriConfig_GetSigningKey_Call) Return(_a0 string) *MockSatoriConfig_GetSigningKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatoriConfig_GetSigningKey_Call) RunAndReturn(run func() string) *MockSatoriConfig_GetSigningKey_Call { + _c.Call.Return(run) + return _c +} + +// GetUrl provides a mock function with no fields +func (_m *MockSatoriConfig) GetUrl() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetUrl") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSatoriConfig_GetUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUrl' +type MockSatoriConfig_GetUrl_Call struct { + *mock.Call +} + +// GetUrl is a helper method to define mock.On call +func (_e *MockSatoriConfig_Expecter) GetUrl() *MockSatoriConfig_GetUrl_Call { + return &MockSatoriConfig_GetUrl_Call{Call: _e.mock.On("GetUrl")} +} + +func (_c *MockSatoriConfig_GetUrl_Call) Run(run func()) *MockSatoriConfig_GetUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSatoriConfig_GetUrl_Call) Return(_a0 string) *MockSatoriConfig_GetUrl_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSatoriConfig_GetUrl_Call) RunAndReturn(run func() string) *MockSatoriConfig_GetUrl_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSatoriConfig creates a new instance of MockSatoriConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSatoriConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSatoriConfig { + mock := &MockSatoriConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SessionConfig.go b/relay/nakama/mocks/mock_SessionConfig.go new file mode 100644 index 000000000..5f5807cb2 --- /dev/null +++ b/relay/nakama/mocks/mock_SessionConfig.go @@ -0,0 +1,392 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSessionConfig is an autogenerated mock type for the SessionConfig type +type MockSessionConfig struct { + mock.Mock +} + +type MockSessionConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSessionConfig) EXPECT() *MockSessionConfig_Expecter { + return &MockSessionConfig_Expecter{mock: &_m.Mock} +} + +// GetEncryptionKey provides a mock function with no fields +func (_m *MockSessionConfig) GetEncryptionKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetEncryptionKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSessionConfig_GetEncryptionKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEncryptionKey' +type MockSessionConfig_GetEncryptionKey_Call struct { + *mock.Call +} + +// GetEncryptionKey is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetEncryptionKey() *MockSessionConfig_GetEncryptionKey_Call { + return &MockSessionConfig_GetEncryptionKey_Call{Call: _e.mock.On("GetEncryptionKey")} +} + +func (_c *MockSessionConfig_GetEncryptionKey_Call) Run(run func()) *MockSessionConfig_GetEncryptionKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetEncryptionKey_Call) Return(_a0 string) *MockSessionConfig_GetEncryptionKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetEncryptionKey_Call) RunAndReturn(run func() string) *MockSessionConfig_GetEncryptionKey_Call { + _c.Call.Return(run) + return _c +} + +// GetRefreshEncryptionKey provides a mock function with no fields +func (_m *MockSessionConfig) GetRefreshEncryptionKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRefreshEncryptionKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSessionConfig_GetRefreshEncryptionKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefreshEncryptionKey' +type MockSessionConfig_GetRefreshEncryptionKey_Call struct { + *mock.Call +} + +// GetRefreshEncryptionKey is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetRefreshEncryptionKey() *MockSessionConfig_GetRefreshEncryptionKey_Call { + return &MockSessionConfig_GetRefreshEncryptionKey_Call{Call: _e.mock.On("GetRefreshEncryptionKey")} +} + +func (_c *MockSessionConfig_GetRefreshEncryptionKey_Call) Run(run func()) *MockSessionConfig_GetRefreshEncryptionKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetRefreshEncryptionKey_Call) Return(_a0 string) *MockSessionConfig_GetRefreshEncryptionKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetRefreshEncryptionKey_Call) RunAndReturn(run func() string) *MockSessionConfig_GetRefreshEncryptionKey_Call { + _c.Call.Return(run) + return _c +} + +// GetRefreshTokenExpirySec provides a mock function with no fields +func (_m *MockSessionConfig) GetRefreshTokenExpirySec() int64 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRefreshTokenExpirySec") + } + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +// MockSessionConfig_GetRefreshTokenExpirySec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefreshTokenExpirySec' +type MockSessionConfig_GetRefreshTokenExpirySec_Call struct { + *mock.Call +} + +// GetRefreshTokenExpirySec is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetRefreshTokenExpirySec() *MockSessionConfig_GetRefreshTokenExpirySec_Call { + return &MockSessionConfig_GetRefreshTokenExpirySec_Call{Call: _e.mock.On("GetRefreshTokenExpirySec")} +} + +func (_c *MockSessionConfig_GetRefreshTokenExpirySec_Call) Run(run func()) *MockSessionConfig_GetRefreshTokenExpirySec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetRefreshTokenExpirySec_Call) Return(_a0 int64) *MockSessionConfig_GetRefreshTokenExpirySec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetRefreshTokenExpirySec_Call) RunAndReturn(run func() int64) *MockSessionConfig_GetRefreshTokenExpirySec_Call { + _c.Call.Return(run) + return _c +} + +// GetSingleMatch provides a mock function with no fields +func (_m *MockSessionConfig) GetSingleMatch() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSingleMatch") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockSessionConfig_GetSingleMatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSingleMatch' +type MockSessionConfig_GetSingleMatch_Call struct { + *mock.Call +} + +// GetSingleMatch is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetSingleMatch() *MockSessionConfig_GetSingleMatch_Call { + return &MockSessionConfig_GetSingleMatch_Call{Call: _e.mock.On("GetSingleMatch")} +} + +func (_c *MockSessionConfig_GetSingleMatch_Call) Run(run func()) *MockSessionConfig_GetSingleMatch_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetSingleMatch_Call) Return(_a0 bool) *MockSessionConfig_GetSingleMatch_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetSingleMatch_Call) RunAndReturn(run func() bool) *MockSessionConfig_GetSingleMatch_Call { + _c.Call.Return(run) + return _c +} + +// GetSingleParty provides a mock function with no fields +func (_m *MockSessionConfig) GetSingleParty() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSingleParty") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockSessionConfig_GetSingleParty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSingleParty' +type MockSessionConfig_GetSingleParty_Call struct { + *mock.Call +} + +// GetSingleParty is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetSingleParty() *MockSessionConfig_GetSingleParty_Call { + return &MockSessionConfig_GetSingleParty_Call{Call: _e.mock.On("GetSingleParty")} +} + +func (_c *MockSessionConfig_GetSingleParty_Call) Run(run func()) *MockSessionConfig_GetSingleParty_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetSingleParty_Call) Return(_a0 bool) *MockSessionConfig_GetSingleParty_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetSingleParty_Call) RunAndReturn(run func() bool) *MockSessionConfig_GetSingleParty_Call { + _c.Call.Return(run) + return _c +} + +// GetSingleSession provides a mock function with no fields +func (_m *MockSessionConfig) GetSingleSession() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSingleSession") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockSessionConfig_GetSingleSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSingleSession' +type MockSessionConfig_GetSingleSession_Call struct { + *mock.Call +} + +// GetSingleSession is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetSingleSession() *MockSessionConfig_GetSingleSession_Call { + return &MockSessionConfig_GetSingleSession_Call{Call: _e.mock.On("GetSingleSession")} +} + +func (_c *MockSessionConfig_GetSingleSession_Call) Run(run func()) *MockSessionConfig_GetSingleSession_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetSingleSession_Call) Return(_a0 bool) *MockSessionConfig_GetSingleSession_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetSingleSession_Call) RunAndReturn(run func() bool) *MockSessionConfig_GetSingleSession_Call { + _c.Call.Return(run) + return _c +} + +// GetSingleSocket provides a mock function with no fields +func (_m *MockSessionConfig) GetSingleSocket() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSingleSocket") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// MockSessionConfig_GetSingleSocket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSingleSocket' +type MockSessionConfig_GetSingleSocket_Call struct { + *mock.Call +} + +// GetSingleSocket is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetSingleSocket() *MockSessionConfig_GetSingleSocket_Call { + return &MockSessionConfig_GetSingleSocket_Call{Call: _e.mock.On("GetSingleSocket")} +} + +func (_c *MockSessionConfig_GetSingleSocket_Call) Run(run func()) *MockSessionConfig_GetSingleSocket_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetSingleSocket_Call) Return(_a0 bool) *MockSessionConfig_GetSingleSocket_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetSingleSocket_Call) RunAndReturn(run func() bool) *MockSessionConfig_GetSingleSocket_Call { + _c.Call.Return(run) + return _c +} + +// GetTokenExpirySec provides a mock function with no fields +func (_m *MockSessionConfig) GetTokenExpirySec() int64 { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetTokenExpirySec") + } + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +// MockSessionConfig_GetTokenExpirySec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTokenExpirySec' +type MockSessionConfig_GetTokenExpirySec_Call struct { + *mock.Call +} + +// GetTokenExpirySec is a helper method to define mock.On call +func (_e *MockSessionConfig_Expecter) GetTokenExpirySec() *MockSessionConfig_GetTokenExpirySec_Call { + return &MockSessionConfig_GetTokenExpirySec_Call{Call: _e.mock.On("GetTokenExpirySec")} +} + +func (_c *MockSessionConfig_GetTokenExpirySec_Call) Run(run func()) *MockSessionConfig_GetTokenExpirySec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSessionConfig_GetTokenExpirySec_Call) Return(_a0 int64) *MockSessionConfig_GetTokenExpirySec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSessionConfig_GetTokenExpirySec_Call) RunAndReturn(run func() int64) *MockSessionConfig_GetTokenExpirySec_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSessionConfig creates a new instance of MockSessionConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSessionConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSessionConfig { + mock := &MockSessionConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocialConfig.go b/relay/nakama/mocks/mock_SocialConfig.go new file mode 100644 index 000000000..b38abe90d --- /dev/null +++ b/relay/nakama/mocks/mock_SocialConfig.go @@ -0,0 +1,223 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import ( + runtime "github.com/heroiclabs/nakama-common/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockSocialConfig is an autogenerated mock type for the SocialConfig type +type MockSocialConfig struct { + mock.Mock +} + +type MockSocialConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocialConfig) EXPECT() *MockSocialConfig_Expecter { + return &MockSocialConfig_Expecter{mock: &_m.Mock} +} + +// GetApple provides a mock function with no fields +func (_m *MockSocialConfig) GetApple() runtime.SocialConfigApple { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetApple") + } + + var r0 runtime.SocialConfigApple + if rf, ok := ret.Get(0).(func() runtime.SocialConfigApple); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocialConfigApple) + } + } + + return r0 +} + +// MockSocialConfig_GetApple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetApple' +type MockSocialConfig_GetApple_Call struct { + *mock.Call +} + +// GetApple is a helper method to define mock.On call +func (_e *MockSocialConfig_Expecter) GetApple() *MockSocialConfig_GetApple_Call { + return &MockSocialConfig_GetApple_Call{Call: _e.mock.On("GetApple")} +} + +func (_c *MockSocialConfig_GetApple_Call) Run(run func()) *MockSocialConfig_GetApple_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfig_GetApple_Call) Return(_a0 runtime.SocialConfigApple) *MockSocialConfig_GetApple_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfig_GetApple_Call) RunAndReturn(run func() runtime.SocialConfigApple) *MockSocialConfig_GetApple_Call { + _c.Call.Return(run) + return _c +} + +// GetFacebookInstantGame provides a mock function with no fields +func (_m *MockSocialConfig) GetFacebookInstantGame() runtime.SocialConfigFacebookInstantGame { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetFacebookInstantGame") + } + + var r0 runtime.SocialConfigFacebookInstantGame + if rf, ok := ret.Get(0).(func() runtime.SocialConfigFacebookInstantGame); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocialConfigFacebookInstantGame) + } + } + + return r0 +} + +// MockSocialConfig_GetFacebookInstantGame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFacebookInstantGame' +type MockSocialConfig_GetFacebookInstantGame_Call struct { + *mock.Call +} + +// GetFacebookInstantGame is a helper method to define mock.On call +func (_e *MockSocialConfig_Expecter) GetFacebookInstantGame() *MockSocialConfig_GetFacebookInstantGame_Call { + return &MockSocialConfig_GetFacebookInstantGame_Call{Call: _e.mock.On("GetFacebookInstantGame")} +} + +func (_c *MockSocialConfig_GetFacebookInstantGame_Call) Run(run func()) *MockSocialConfig_GetFacebookInstantGame_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfig_GetFacebookInstantGame_Call) Return(_a0 runtime.SocialConfigFacebookInstantGame) *MockSocialConfig_GetFacebookInstantGame_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfig_GetFacebookInstantGame_Call) RunAndReturn(run func() runtime.SocialConfigFacebookInstantGame) *MockSocialConfig_GetFacebookInstantGame_Call { + _c.Call.Return(run) + return _c +} + +// GetFacebookLimitedLogin provides a mock function with no fields +func (_m *MockSocialConfig) GetFacebookLimitedLogin() runtime.SocialConfigFacebookLimitedLogin { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetFacebookLimitedLogin") + } + + var r0 runtime.SocialConfigFacebookLimitedLogin + if rf, ok := ret.Get(0).(func() runtime.SocialConfigFacebookLimitedLogin); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocialConfigFacebookLimitedLogin) + } + } + + return r0 +} + +// MockSocialConfig_GetFacebookLimitedLogin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFacebookLimitedLogin' +type MockSocialConfig_GetFacebookLimitedLogin_Call struct { + *mock.Call +} + +// GetFacebookLimitedLogin is a helper method to define mock.On call +func (_e *MockSocialConfig_Expecter) GetFacebookLimitedLogin() *MockSocialConfig_GetFacebookLimitedLogin_Call { + return &MockSocialConfig_GetFacebookLimitedLogin_Call{Call: _e.mock.On("GetFacebookLimitedLogin")} +} + +func (_c *MockSocialConfig_GetFacebookLimitedLogin_Call) Run(run func()) *MockSocialConfig_GetFacebookLimitedLogin_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfig_GetFacebookLimitedLogin_Call) Return(_a0 runtime.SocialConfigFacebookLimitedLogin) *MockSocialConfig_GetFacebookLimitedLogin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfig_GetFacebookLimitedLogin_Call) RunAndReturn(run func() runtime.SocialConfigFacebookLimitedLogin) *MockSocialConfig_GetFacebookLimitedLogin_Call { + _c.Call.Return(run) + return _c +} + +// GetSteam provides a mock function with no fields +func (_m *MockSocialConfig) GetSteam() runtime.SocialConfigSteam { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetSteam") + } + + var r0 runtime.SocialConfigSteam + if rf, ok := ret.Get(0).(func() runtime.SocialConfigSteam); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(runtime.SocialConfigSteam) + } + } + + return r0 +} + +// MockSocialConfig_GetSteam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSteam' +type MockSocialConfig_GetSteam_Call struct { + *mock.Call +} + +// GetSteam is a helper method to define mock.On call +func (_e *MockSocialConfig_Expecter) GetSteam() *MockSocialConfig_GetSteam_Call { + return &MockSocialConfig_GetSteam_Call{Call: _e.mock.On("GetSteam")} +} + +func (_c *MockSocialConfig_GetSteam_Call) Run(run func()) *MockSocialConfig_GetSteam_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfig_GetSteam_Call) Return(_a0 runtime.SocialConfigSteam) *MockSocialConfig_GetSteam_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfig_GetSteam_Call) RunAndReturn(run func() runtime.SocialConfigSteam) *MockSocialConfig_GetSteam_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocialConfig creates a new instance of MockSocialConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocialConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocialConfig { + mock := &MockSocialConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocialConfigApple.go b/relay/nakama/mocks/mock_SocialConfigApple.go new file mode 100644 index 000000000..ab4b65817 --- /dev/null +++ b/relay/nakama/mocks/mock_SocialConfigApple.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSocialConfigApple is an autogenerated mock type for the SocialConfigApple type +type MockSocialConfigApple struct { + mock.Mock +} + +type MockSocialConfigApple_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocialConfigApple) EXPECT() *MockSocialConfigApple_Expecter { + return &MockSocialConfigApple_Expecter{mock: &_m.Mock} +} + +// GetBundleId provides a mock function with no fields +func (_m *MockSocialConfigApple) GetBundleId() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetBundleId") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocialConfigApple_GetBundleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBundleId' +type MockSocialConfigApple_GetBundleId_Call struct { + *mock.Call +} + +// GetBundleId is a helper method to define mock.On call +func (_e *MockSocialConfigApple_Expecter) GetBundleId() *MockSocialConfigApple_GetBundleId_Call { + return &MockSocialConfigApple_GetBundleId_Call{Call: _e.mock.On("GetBundleId")} +} + +func (_c *MockSocialConfigApple_GetBundleId_Call) Run(run func()) *MockSocialConfigApple_GetBundleId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfigApple_GetBundleId_Call) Return(_a0 string) *MockSocialConfigApple_GetBundleId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfigApple_GetBundleId_Call) RunAndReturn(run func() string) *MockSocialConfigApple_GetBundleId_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocialConfigApple creates a new instance of MockSocialConfigApple. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocialConfigApple(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocialConfigApple { + mock := &MockSocialConfigApple{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocialConfigFacebookInstantGame.go b/relay/nakama/mocks/mock_SocialConfigFacebookInstantGame.go new file mode 100644 index 000000000..9c290ea80 --- /dev/null +++ b/relay/nakama/mocks/mock_SocialConfigFacebookInstantGame.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSocialConfigFacebookInstantGame is an autogenerated mock type for the SocialConfigFacebookInstantGame type +type MockSocialConfigFacebookInstantGame struct { + mock.Mock +} + +type MockSocialConfigFacebookInstantGame_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocialConfigFacebookInstantGame) EXPECT() *MockSocialConfigFacebookInstantGame_Expecter { + return &MockSocialConfigFacebookInstantGame_Expecter{mock: &_m.Mock} +} + +// GetAppSecret provides a mock function with no fields +func (_m *MockSocialConfigFacebookInstantGame) GetAppSecret() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAppSecret") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocialConfigFacebookInstantGame_GetAppSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppSecret' +type MockSocialConfigFacebookInstantGame_GetAppSecret_Call struct { + *mock.Call +} + +// GetAppSecret is a helper method to define mock.On call +func (_e *MockSocialConfigFacebookInstantGame_Expecter) GetAppSecret() *MockSocialConfigFacebookInstantGame_GetAppSecret_Call { + return &MockSocialConfigFacebookInstantGame_GetAppSecret_Call{Call: _e.mock.On("GetAppSecret")} +} + +func (_c *MockSocialConfigFacebookInstantGame_GetAppSecret_Call) Run(run func()) *MockSocialConfigFacebookInstantGame_GetAppSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfigFacebookInstantGame_GetAppSecret_Call) Return(_a0 string) *MockSocialConfigFacebookInstantGame_GetAppSecret_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfigFacebookInstantGame_GetAppSecret_Call) RunAndReturn(run func() string) *MockSocialConfigFacebookInstantGame_GetAppSecret_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocialConfigFacebookInstantGame creates a new instance of MockSocialConfigFacebookInstantGame. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocialConfigFacebookInstantGame(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocialConfigFacebookInstantGame { + mock := &MockSocialConfigFacebookInstantGame{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocialConfigFacebookLimitedLogin.go b/relay/nakama/mocks/mock_SocialConfigFacebookLimitedLogin.go new file mode 100644 index 000000000..d1c146844 --- /dev/null +++ b/relay/nakama/mocks/mock_SocialConfigFacebookLimitedLogin.go @@ -0,0 +1,77 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSocialConfigFacebookLimitedLogin is an autogenerated mock type for the SocialConfigFacebookLimitedLogin type +type MockSocialConfigFacebookLimitedLogin struct { + mock.Mock +} + +type MockSocialConfigFacebookLimitedLogin_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocialConfigFacebookLimitedLogin) EXPECT() *MockSocialConfigFacebookLimitedLogin_Expecter { + return &MockSocialConfigFacebookLimitedLogin_Expecter{mock: &_m.Mock} +} + +// GetAppId provides a mock function with no fields +func (_m *MockSocialConfigFacebookLimitedLogin) GetAppId() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAppId") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocialConfigFacebookLimitedLogin_GetAppId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppId' +type MockSocialConfigFacebookLimitedLogin_GetAppId_Call struct { + *mock.Call +} + +// GetAppId is a helper method to define mock.On call +func (_e *MockSocialConfigFacebookLimitedLogin_Expecter) GetAppId() *MockSocialConfigFacebookLimitedLogin_GetAppId_Call { + return &MockSocialConfigFacebookLimitedLogin_GetAppId_Call{Call: _e.mock.On("GetAppId")} +} + +func (_c *MockSocialConfigFacebookLimitedLogin_GetAppId_Call) Run(run func()) *MockSocialConfigFacebookLimitedLogin_GetAppId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfigFacebookLimitedLogin_GetAppId_Call) Return(_a0 string) *MockSocialConfigFacebookLimitedLogin_GetAppId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfigFacebookLimitedLogin_GetAppId_Call) RunAndReturn(run func() string) *MockSocialConfigFacebookLimitedLogin_GetAppId_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocialConfigFacebookLimitedLogin creates a new instance of MockSocialConfigFacebookLimitedLogin. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocialConfigFacebookLimitedLogin(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocialConfigFacebookLimitedLogin { + mock := &MockSocialConfigFacebookLimitedLogin{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocialConfigSteam.go b/relay/nakama/mocks/mock_SocialConfigSteam.go new file mode 100644 index 000000000..4b27a91b8 --- /dev/null +++ b/relay/nakama/mocks/mock_SocialConfigSteam.go @@ -0,0 +1,122 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSocialConfigSteam is an autogenerated mock type for the SocialConfigSteam type +type MockSocialConfigSteam struct { + mock.Mock +} + +type MockSocialConfigSteam_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocialConfigSteam) EXPECT() *MockSocialConfigSteam_Expecter { + return &MockSocialConfigSteam_Expecter{mock: &_m.Mock} +} + +// GetAppID provides a mock function with no fields +func (_m *MockSocialConfigSteam) GetAppID() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAppID") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// MockSocialConfigSteam_GetAppID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppID' +type MockSocialConfigSteam_GetAppID_Call struct { + *mock.Call +} + +// GetAppID is a helper method to define mock.On call +func (_e *MockSocialConfigSteam_Expecter) GetAppID() *MockSocialConfigSteam_GetAppID_Call { + return &MockSocialConfigSteam_GetAppID_Call{Call: _e.mock.On("GetAppID")} +} + +func (_c *MockSocialConfigSteam_GetAppID_Call) Run(run func()) *MockSocialConfigSteam_GetAppID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfigSteam_GetAppID_Call) Return(_a0 int) *MockSocialConfigSteam_GetAppID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfigSteam_GetAppID_Call) RunAndReturn(run func() int) *MockSocialConfigSteam_GetAppID_Call { + _c.Call.Return(run) + return _c +} + +// GetPublisherKey provides a mock function with no fields +func (_m *MockSocialConfigSteam) GetPublisherKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPublisherKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocialConfigSteam_GetPublisherKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublisherKey' +type MockSocialConfigSteam_GetPublisherKey_Call struct { + *mock.Call +} + +// GetPublisherKey is a helper method to define mock.On call +func (_e *MockSocialConfigSteam_Expecter) GetPublisherKey() *MockSocialConfigSteam_GetPublisherKey_Call { + return &MockSocialConfigSteam_GetPublisherKey_Call{Call: _e.mock.On("GetPublisherKey")} +} + +func (_c *MockSocialConfigSteam_GetPublisherKey_Call) Run(run func()) *MockSocialConfigSteam_GetPublisherKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocialConfigSteam_GetPublisherKey_Call) Return(_a0 string) *MockSocialConfigSteam_GetPublisherKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocialConfigSteam_GetPublisherKey_Call) RunAndReturn(run func() string) *MockSocialConfigSteam_GetPublisherKey_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocialConfigSteam creates a new instance of MockSocialConfigSteam. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocialConfigSteam(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocialConfigSteam { + mock := &MockSocialConfigSteam{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_SocketConfig.go b/relay/nakama/mocks/mock_SocketConfig.go new file mode 100644 index 000000000..9c7f4652c --- /dev/null +++ b/relay/nakama/mocks/mock_SocketConfig.go @@ -0,0 +1,212 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// MockSocketConfig is an autogenerated mock type for the SocketConfig type +type MockSocketConfig struct { + mock.Mock +} + +type MockSocketConfig_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSocketConfig) EXPECT() *MockSocketConfig_Expecter { + return &MockSocketConfig_Expecter{mock: &_m.Mock} +} + +// GetAddress provides a mock function with no fields +func (_m *MockSocketConfig) GetAddress() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAddress") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocketConfig_GetAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAddress' +type MockSocketConfig_GetAddress_Call struct { + *mock.Call +} + +// GetAddress is a helper method to define mock.On call +func (_e *MockSocketConfig_Expecter) GetAddress() *MockSocketConfig_GetAddress_Call { + return &MockSocketConfig_GetAddress_Call{Call: _e.mock.On("GetAddress")} +} + +func (_c *MockSocketConfig_GetAddress_Call) Run(run func()) *MockSocketConfig_GetAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocketConfig_GetAddress_Call) Return(_a0 string) *MockSocketConfig_GetAddress_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocketConfig_GetAddress_Call) RunAndReturn(run func() string) *MockSocketConfig_GetAddress_Call { + _c.Call.Return(run) + return _c +} + +// GetPort provides a mock function with no fields +func (_m *MockSocketConfig) GetPort() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetPort") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// MockSocketConfig_GetPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPort' +type MockSocketConfig_GetPort_Call struct { + *mock.Call +} + +// GetPort is a helper method to define mock.On call +func (_e *MockSocketConfig_Expecter) GetPort() *MockSocketConfig_GetPort_Call { + return &MockSocketConfig_GetPort_Call{Call: _e.mock.On("GetPort")} +} + +func (_c *MockSocketConfig_GetPort_Call) Run(run func()) *MockSocketConfig_GetPort_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocketConfig_GetPort_Call) Return(_a0 int) *MockSocketConfig_GetPort_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocketConfig_GetPort_Call) RunAndReturn(run func() int) *MockSocketConfig_GetPort_Call { + _c.Call.Return(run) + return _c +} + +// GetProtocol provides a mock function with no fields +func (_m *MockSocketConfig) GetProtocol() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetProtocol") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocketConfig_GetProtocol_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProtocol' +type MockSocketConfig_GetProtocol_Call struct { + *mock.Call +} + +// GetProtocol is a helper method to define mock.On call +func (_e *MockSocketConfig_Expecter) GetProtocol() *MockSocketConfig_GetProtocol_Call { + return &MockSocketConfig_GetProtocol_Call{Call: _e.mock.On("GetProtocol")} +} + +func (_c *MockSocketConfig_GetProtocol_Call) Run(run func()) *MockSocketConfig_GetProtocol_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocketConfig_GetProtocol_Call) Return(_a0 string) *MockSocketConfig_GetProtocol_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocketConfig_GetProtocol_Call) RunAndReturn(run func() string) *MockSocketConfig_GetProtocol_Call { + _c.Call.Return(run) + return _c +} + +// GetServerKey provides a mock function with no fields +func (_m *MockSocketConfig) GetServerKey() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetServerKey") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSocketConfig_GetServerKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerKey' +type MockSocketConfig_GetServerKey_Call struct { + *mock.Call +} + +// GetServerKey is a helper method to define mock.On call +func (_e *MockSocketConfig_Expecter) GetServerKey() *MockSocketConfig_GetServerKey_Call { + return &MockSocketConfig_GetServerKey_Call{Call: _e.mock.On("GetServerKey")} +} + +func (_c *MockSocketConfig_GetServerKey_Call) Run(run func()) *MockSocketConfig_GetServerKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSocketConfig_GetServerKey_Call) Return(_a0 string) *MockSocketConfig_GetServerKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSocketConfig_GetServerKey_Call) RunAndReturn(run func() string) *MockSocketConfig_GetServerKey_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSocketConfig creates a new instance of MockSocketConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSocketConfig(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSocketConfig { + mock := &MockSocketConfig{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/relay/nakama/mocks/mock_WalletLedgerItem.go b/relay/nakama/mocks/mock_WalletLedgerItem.go index 99e5acb25..5e89b8746 100644 --- a/relay/nakama/mocks/mock_WalletLedgerItem.go +++ b/relay/nakama/mocks/mock_WalletLedgerItem.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.23.1. DO NOT EDIT. +// Code generated by mockery v2.50.0. DO NOT EDIT. package mocks @@ -9,10 +9,22 @@ type MockWalletLedgerItem struct { mock.Mock } -// GetChangeset provides a mock function with given fields: +type MockWalletLedgerItem_Expecter struct { + mock *mock.Mock +} + +func (_m *MockWalletLedgerItem) EXPECT() *MockWalletLedgerItem_Expecter { + return &MockWalletLedgerItem_Expecter{mock: &_m.Mock} +} + +// GetChangeset provides a mock function with no fields func (_m *MockWalletLedgerItem) GetChangeset() map[string]int64 { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetChangeset") + } + var r0 map[string]int64 if rf, ok := ret.Get(0).(func() map[string]int64); ok { r0 = rf() @@ -25,10 +37,41 @@ func (_m *MockWalletLedgerItem) GetChangeset() map[string]int64 { return r0 } -// GetCreateTime provides a mock function with given fields: +// MockWalletLedgerItem_GetChangeset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChangeset' +type MockWalletLedgerItem_GetChangeset_Call struct { + *mock.Call +} + +// GetChangeset is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetChangeset() *MockWalletLedgerItem_GetChangeset_Call { + return &MockWalletLedgerItem_GetChangeset_Call{Call: _e.mock.On("GetChangeset")} +} + +func (_c *MockWalletLedgerItem_GetChangeset_Call) Run(run func()) *MockWalletLedgerItem_GetChangeset_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetChangeset_Call) Return(_a0 map[string]int64) *MockWalletLedgerItem_GetChangeset_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetChangeset_Call) RunAndReturn(run func() map[string]int64) *MockWalletLedgerItem_GetChangeset_Call { + _c.Call.Return(run) + return _c +} + +// GetCreateTime provides a mock function with no fields func (_m *MockWalletLedgerItem) GetCreateTime() int64 { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetCreateTime") + } + var r0 int64 if rf, ok := ret.Get(0).(func() int64); ok { r0 = rf() @@ -39,10 +82,41 @@ func (_m *MockWalletLedgerItem) GetCreateTime() int64 { return r0 } -// GetID provides a mock function with given fields: +// MockWalletLedgerItem_GetCreateTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreateTime' +type MockWalletLedgerItem_GetCreateTime_Call struct { + *mock.Call +} + +// GetCreateTime is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetCreateTime() *MockWalletLedgerItem_GetCreateTime_Call { + return &MockWalletLedgerItem_GetCreateTime_Call{Call: _e.mock.On("GetCreateTime")} +} + +func (_c *MockWalletLedgerItem_GetCreateTime_Call) Run(run func()) *MockWalletLedgerItem_GetCreateTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetCreateTime_Call) Return(_a0 int64) *MockWalletLedgerItem_GetCreateTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetCreateTime_Call) RunAndReturn(run func() int64) *MockWalletLedgerItem_GetCreateTime_Call { + _c.Call.Return(run) + return _c +} + +// GetID provides a mock function with no fields func (_m *MockWalletLedgerItem) GetID() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetID") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -53,10 +127,41 @@ func (_m *MockWalletLedgerItem) GetID() string { return r0 } -// GetMetadata provides a mock function with given fields: +// MockWalletLedgerItem_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID' +type MockWalletLedgerItem_GetID_Call struct { + *mock.Call +} + +// GetID is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetID() *MockWalletLedgerItem_GetID_Call { + return &MockWalletLedgerItem_GetID_Call{Call: _e.mock.On("GetID")} +} + +func (_c *MockWalletLedgerItem_GetID_Call) Run(run func()) *MockWalletLedgerItem_GetID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetID_Call) Return(_a0 string) *MockWalletLedgerItem_GetID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetID_Call) RunAndReturn(run func() string) *MockWalletLedgerItem_GetID_Call { + _c.Call.Return(run) + return _c +} + +// GetMetadata provides a mock function with no fields func (_m *MockWalletLedgerItem) GetMetadata() map[string]interface{} { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetMetadata") + } + var r0 map[string]interface{} if rf, ok := ret.Get(0).(func() map[string]interface{}); ok { r0 = rf() @@ -69,10 +174,41 @@ func (_m *MockWalletLedgerItem) GetMetadata() map[string]interface{} { return r0 } -// GetUpdateTime provides a mock function with given fields: +// MockWalletLedgerItem_GetMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMetadata' +type MockWalletLedgerItem_GetMetadata_Call struct { + *mock.Call +} + +// GetMetadata is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetMetadata() *MockWalletLedgerItem_GetMetadata_Call { + return &MockWalletLedgerItem_GetMetadata_Call{Call: _e.mock.On("GetMetadata")} +} + +func (_c *MockWalletLedgerItem_GetMetadata_Call) Run(run func()) *MockWalletLedgerItem_GetMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetMetadata_Call) Return(_a0 map[string]interface{}) *MockWalletLedgerItem_GetMetadata_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetMetadata_Call) RunAndReturn(run func() map[string]interface{}) *MockWalletLedgerItem_GetMetadata_Call { + _c.Call.Return(run) + return _c +} + +// GetUpdateTime provides a mock function with no fields func (_m *MockWalletLedgerItem) GetUpdateTime() int64 { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUpdateTime") + } + var r0 int64 if rf, ok := ret.Get(0).(func() int64); ok { r0 = rf() @@ -83,10 +219,41 @@ func (_m *MockWalletLedgerItem) GetUpdateTime() int64 { return r0 } -// GetUserID provides a mock function with given fields: +// MockWalletLedgerItem_GetUpdateTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdateTime' +type MockWalletLedgerItem_GetUpdateTime_Call struct { + *mock.Call +} + +// GetUpdateTime is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetUpdateTime() *MockWalletLedgerItem_GetUpdateTime_Call { + return &MockWalletLedgerItem_GetUpdateTime_Call{Call: _e.mock.On("GetUpdateTime")} +} + +func (_c *MockWalletLedgerItem_GetUpdateTime_Call) Run(run func()) *MockWalletLedgerItem_GetUpdateTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetUpdateTime_Call) Return(_a0 int64) *MockWalletLedgerItem_GetUpdateTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetUpdateTime_Call) RunAndReturn(run func() int64) *MockWalletLedgerItem_GetUpdateTime_Call { + _c.Call.Return(run) + return _c +} + +// GetUserID provides a mock function with no fields func (_m *MockWalletLedgerItem) GetUserID() string { ret := _m.Called() + if len(ret) == 0 { + panic("no return value specified for GetUserID") + } + var r0 string if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() @@ -97,13 +264,39 @@ func (_m *MockWalletLedgerItem) GetUserID() string { return r0 } -type mockConstructorTestingTNewMockWalletLedgerItem interface { - mock.TestingT - Cleanup(func()) +// MockWalletLedgerItem_GetUserID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserID' +type MockWalletLedgerItem_GetUserID_Call struct { + *mock.Call +} + +// GetUserID is a helper method to define mock.On call +func (_e *MockWalletLedgerItem_Expecter) GetUserID() *MockWalletLedgerItem_GetUserID_Call { + return &MockWalletLedgerItem_GetUserID_Call{Call: _e.mock.On("GetUserID")} +} + +func (_c *MockWalletLedgerItem_GetUserID_Call) Run(run func()) *MockWalletLedgerItem_GetUserID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWalletLedgerItem_GetUserID_Call) Return(_a0 string) *MockWalletLedgerItem_GetUserID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWalletLedgerItem_GetUserID_Call) RunAndReturn(run func() string) *MockWalletLedgerItem_GetUserID_Call { + _c.Call.Return(run) + return _c } // NewMockWalletLedgerItem creates a new instance of MockWalletLedgerItem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -func NewMockWalletLedgerItem(t mockConstructorTestingTNewMockWalletLedgerItem) *MockWalletLedgerItem { +// The first argument is typically a *testing.T value. +func NewMockWalletLedgerItem(t interface { + mock.TestingT + Cleanup(func()) +}) *MockWalletLedgerItem { mock := &MockWalletLedgerItem{} mock.Mock.Test(t) diff --git a/relay/nakama/utils/nakama.go b/relay/nakama/utils/nakama.go index 301616900..a510c0539 100644 --- a/relay/nakama/utils/nakama.go +++ b/relay/nakama/utils/nakama.go @@ -22,7 +22,7 @@ func GetUserID(ctx context.Context) (string, error) { return userID, nil } -// MarshalResult marshals the given result and converts any marshalling error into a "Internal" RPC error. +// MarshalResult marshals the given result and converts any marshalling error into an "Internal" RPC error. func MarshalResult(logger runtime.Logger, result any) (string, error) { bz, err := json.Marshal(result) if err != nil {