diff --git a/.env b/.env new file mode 100644 index 0000000..4512d0d --- /dev/null +++ b/.env @@ -0,0 +1,2 @@ +# version +GOLANG_VERSION=1.22 diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index f6c62e6..55331cf 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -9,11 +9,17 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/setup-go@v1 + - uses: actions/checkout@v4 + + - name: Load .env file + uses: cardinalby/export-env-action@v2 with: - go-version: 1.21 + envFile: .env - - uses: actions/checkout@v3 + - uses: actions/setup-go@v5 + with: + go-version: ${{ env.GOLANG_VERSION }} + cache: false - name: Generate coverage report run: | diff --git a/.github/workflows/golangci-lint.yaml b/.github/workflows/golangci-lint.yaml new file mode 100644 index 0000000..c45973b --- /dev/null +++ b/.github/workflows/golangci-lint.yaml @@ -0,0 +1,31 @@ +name: golangci-lint + +on: + push: + pull_request: + +permissions: + contents: read + +jobs: + golangci: + name: lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Load .env file + uses: cardinalby/export-env-action@v2 + with: + envFile: .env + + - uses: actions/setup-go@v5 + with: + go-version: ${{ env.GOLANG_VERSION }} + cache: false + + - name: golangci-lint + uses: golangci/golangci-lint-action@v3 + with: + version: v1.54 + args: --timeout=10m diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..485dee6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.idea diff --git a/async/async.go b/async/async.go new file mode 100644 index 0000000..2aac7cd --- /dev/null +++ b/async/async.go @@ -0,0 +1,15 @@ +package async + +import "fmt" + +func GoSafe(fn func()) { + go func() { + defer func() { + if r := recover(); r != nil { + fmt.Printf("go routine recovered from panic: %s\n", r) + } + }() + + fn() + }() +} diff --git a/constant/constant.go b/constant/constant.go new file mode 100644 index 0000000..a06472a --- /dev/null +++ b/constant/constant.go @@ -0,0 +1,9 @@ +package constant + +const ( + HeaderUserUIDKey = "Instill-User-Uid" + HeaderRequesterUIDKey = "Instill-Requester-Uid" + HeaderUserAgent = "Instill-User-Agent" + + ContentTypeJSON = "application/json" +) diff --git a/go.mod b/go.mod index faada12..4fec8dc 100644 --- a/go.mod +++ b/go.mod @@ -1,12 +1,15 @@ module github.com/instill-ai/x -go 1.21 +go 1.22 require ( github.com/frankban/quicktest v1.14.6 - github.com/google/uuid v1.3.0 + github.com/gofrs/uuid v4.4.0+incompatible + github.com/gojuno/minimock/v3 v3.4.0 + github.com/google/uuid v1.6.0 github.com/iancoleman/strcase v0.2.0 - github.com/stretchr/testify v1.7.0 + github.com/minio/minio-go/v7 v7.0.76 + github.com/stretchr/testify v1.9.0 go.temporal.io/sdk v1.13.1 go.uber.org/zap v1.21.0 google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 @@ -16,7 +19,10 @@ require ( require ( github.com/davecgh/go-spew v1.1.1 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a // indirect + github.com/go-ini/ini v1.67.0 // indirect + github.com/goccy/go-json v0.10.3 // indirect github.com/gogo/googleapis v1.4.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/gogo/status v1.1.0 // indirect @@ -24,20 +30,25 @@ require ( github.com/golang/protobuf v1.5.3 // indirect github.com/google/go-cmp v0.5.9 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect + github.com/klauspost/compress v1.17.9 // indirect + github.com/klauspost/cpuid/v2 v2.2.8 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect + github.com/minio/md5-simd v1.1.2 // indirect github.com/pborman/uuid v1.2.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/robfig/cron v1.2.0 // indirect github.com/rogpeppe/go-internal v1.9.0 // indirect - github.com/stretchr/objx v0.3.0 // indirect + github.com/rs/xid v1.6.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect go.temporal.io/api v1.6.1-0.20211110205628-60c98e9cbfe2 // indirect go.uber.org/atomic v1.9.0 // indirect go.uber.org/multierr v1.6.0 // indirect - golang.org/x/net v0.23.0 // indirect - golang.org/x/sys v0.18.0 // indirect - golang.org/x/text v0.14.0 // indirect + golang.org/x/crypto v0.26.0 // indirect + golang.org/x/net v0.28.0 // indirect + golang.org/x/sys v0.24.0 // indirect + golang.org/x/text v0.17.0 // indirect golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - gopkg.in/yaml.v3 v3.0.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 93fd00a..df06255 100644 --- a/go.sum +++ b/go.sum @@ -20,6 +20,8 @@ github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ3 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -32,9 +34,15 @@ github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a/go.mod h1:7Ga40eg github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= +github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA= +github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= +github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0= github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= @@ -43,6 +51,8 @@ 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/gojuno/minimock/v3 v3.4.0 h1:htPGQuFvmCaTygTnARPp5tSWZUZxOnu8A2RDVyl/LA8= +github.com/gojuno/minimock/v3 v3.4.0/go.mod h1:0PdkFMCugnywaAqwrdWMZMzHhSH3ZoXlMVHiRVdIrLk= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= @@ -73,8 +83,9 @@ github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= @@ -82,6 +93,11 @@ github.com/iancoleman/strcase v0.2.0 h1:05I4QRnGpI0m37iZQRuskXh+w77mr6Z41lwQzuHL github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM= +github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= @@ -91,14 +107,18 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.76 h1:9nxHH2XDai61cT/EFhyIw/wW4vJfpPNvl7lSFpRt+Ng= +github.com/minio/minio-go/v7 v7.0.76/go.mod h1:AVM3IUN6WwKzmwBxVdjzhH8xq+f57JSbbvzqvUzR6eg= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw= github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= @@ -107,18 +127,22 @@ github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfm github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.3.0 h1:NGXK3lHquSN08v5vWalVI/L8XU9hdzE/G6xsrze47As= github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= @@ -142,6 +166,8 @@ go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= +golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= 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= @@ -162,8 +188,8 @@ golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81R golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20211109214657-ef0fda0de508/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -185,16 +211,17 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= -golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg= +golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= 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.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac h1:7zkz7BUtwNFFqcowJ+RIgu2MaV/MapERkDIy+mwPyjs= golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -250,8 +277,9 @@ google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGm google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= @@ -259,7 +287,7 @@ gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= -gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/minio/config.go b/minio/config.go new file mode 100644 index 0000000..f4ed01a --- /dev/null +++ b/minio/config.go @@ -0,0 +1,11 @@ +package minio + +// Config is the minio configuration. +type Config struct { + Host string `koanf:"host"` + Port string `koanf:"port"` + RootUser string `koanf:"rootuser"` + RootPwd string `koanf:"rootpwd"` + BucketName string `koanf:"bucketname"` + Secure bool `koanf:"secure"` // Add this line for the Secure option +} diff --git a/minio/minio.go b/minio/minio.go new file mode 100644 index 0000000..a97964a --- /dev/null +++ b/minio/minio.go @@ -0,0 +1,223 @@ +package minio + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "io" + "net" + "sync" + "time" + + "github.com/gofrs/uuid" + "github.com/minio/minio-go/v7/pkg/credentials" + "github.com/minio/minio-go/v7/pkg/lifecycle" + "go.uber.org/zap" + + miniogo "github.com/minio/minio-go/v7" +) + +type MinioI interface { + UploadFile(ctx context.Context, filePath string, fileContent any, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) + UploadFileBytes(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) + DeleteFile(ctx context.Context, logger *zap.Logger, filePath string) (err error) + GetFile(ctx context.Context, logger *zap.Logger, filePath string) ([]byte, error) + GetFilesByPaths(ctx context.Context, logger *zap.Logger, filePaths []string) ([]FileContent, error) +} + +const Location = "us-east-1" + +type minio struct { + client *miniogo.Client + bucket string +} + +func NewMinioClientAndInitBucket(ctx context.Context, cfg *Config, logger *zap.Logger) (MinioI, error) { + logger.Info("Initializing Minio client and bucket...") + + endpoint := net.JoinHostPort(cfg.Host, cfg.Port) + client, err := miniogo.New(endpoint, &miniogo.Options{ + Creds: credentials.NewStaticV4(cfg.RootUser, cfg.RootPwd, ""), + Secure: cfg.Secure, + }) + if err != nil { + logger.Error("cannot connect to minio", + zap.String("host:port", cfg.Host+":"+cfg.Port), + zap.String("user", cfg.RootUser), + zap.String("pwd", cfg.RootPwd), zap.Error(err)) + return nil, err + } + + exists, err := client.BucketExists(ctx, cfg.BucketName) + if err != nil { + logger.Error("failed in checking BucketExists", zap.Error(err)) + return nil, err + } + if exists { + logger.Info("Bucket already exists", zap.String("bucket", cfg.BucketName)) + return &minio{client: client, bucket: cfg.BucketName}, nil + } + + if err = client.MakeBucket(ctx, cfg.BucketName, miniogo.MakeBucketOptions{ + Region: Location, + }); err != nil { + logger.Error("creating Bucket failed", zap.Error(err)) + return nil, err + } + logger.Info("Successfully created bucket", zap.String("bucket", cfg.BucketName)) + + lccfg := lifecycle.NewConfiguration() + lccfg.Rules = []lifecycle.Rule{ + { + ID: "expire-bucket-objects", + Status: "Enabled", + Expiration: lifecycle.Expiration{ + Days: lifecycle.ExpirationDays(30), + }, + }, + } + err = client.SetBucketLifecycle(ctx, cfg.BucketName, lccfg) + if err != nil { + logger.Error("setting Bucket lifecycle failed", zap.Error(err)) + return nil, err + } + + return &minio{client: client, bucket: cfg.BucketName}, nil +} + +func (m *minio) UploadFile(ctx context.Context, filePath string, fileContent any, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) { + jsonData, _ := json.Marshal(fileContent) + return m.UploadFileBytes(ctx, nil, filePath, jsonData, fileMimeType) +} + +func (m *minio) UploadFileBytes(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) { + logger.Info("start to upload file to minio", zap.String("filePath", filePath)) + reader := bytes.NewReader(fileBytes) + + // Create the file path with folder structure + _, err = m.client.PutObject(ctx, m.bucket, filePath, reader, int64(len(fileBytes)), miniogo.PutObjectOptions{ContentType: fileMimeType}) + if err != nil { + logger.Error("Failed to upload file to MinIO", zap.Error(err)) + return "", nil, err + } + + // Get the object stat (metadata) + stat, err := m.client.StatObject(ctx, m.bucket, filePath, miniogo.StatObjectOptions{}) + if err != nil { + return "", nil, err + } + + // Generate the presigned URL + presignedURL, err := m.client.PresignedGetObject(ctx, m.bucket, filePath, time.Hour*24*7, nil) + if err != nil { + return "", nil, err + } + + return presignedURL.String(), &stat, nil +} + +// DeleteFile delete the file from minio +func (m *minio) DeleteFile(ctx context.Context, logger *zap.Logger, filePath string) (err error) { + err = m.client.RemoveObject(ctx, m.bucket, filePath, miniogo.RemoveObjectOptions{}) + if err != nil { + logger.Error("Failed to delete file from MinIO", zap.Error(err)) + return err + } + return nil +} + +// GetFile Get the object using the client +func (m *minio) GetFile(ctx context.Context, logger *zap.Logger, filePath string) ([]byte, error) { + object, err := m.client.GetObject(ctx, m.bucket, filePath, miniogo.GetObjectOptions{}) + if err != nil { + logger.Error("Failed to get file from MinIO", zap.Error(err)) + return nil, err + } + defer object.Close() + + // Read the object's content + buf := new(bytes.Buffer) + _, err = buf.ReadFrom(object) + if err != nil { + logger.Error("Failed to read file from MinIO", zap.Error(err)) + return nil, err + } + + return buf.Bytes(), nil +} + +// FileContent represents a file and its content +type FileContent struct { + Name string + Content []byte +} + +// GetFilesByPaths GetFiles retrieves the contents of specified files from MinIO +func (m *minio) GetFilesByPaths(ctx context.Context, logger *zap.Logger, filePaths []string) ([]FileContent, error) { + var wg sync.WaitGroup + fileCount := len(filePaths) + + errCh := make(chan error, fileCount) + resultCh := make(chan FileContent, fileCount) + + for _, path := range filePaths { + wg.Add(1) + go func(filePath string) { + defer wg.Done() + + obj, err := m.client.GetObject(ctx, m.bucket, filePath, miniogo.GetObjectOptions{}) + if err != nil { + logger.Error("Failed to get object from MinIO", zap.String("path", filePath), zap.Error(err)) + errCh <- err + return + } + defer obj.Close() + + var buffer bytes.Buffer + _, err = io.Copy(&buffer, obj) + if err != nil { + logger.Error("Failed to read object content", zap.String("path", filePath), zap.Error(err)) + errCh <- err + return + } + + fileContent := FileContent{ + Name: filePath, + Content: buffer.Bytes(), + } + resultCh <- fileContent + }(path) + } + + wg.Wait() + + close(errCh) + close(resultCh) + + var errs []error + for err := range errCh { + errs = append(errs, err) + } + + if len(errs) > 0 { + return nil, errors.Join(errs...) + } + + files := make([]FileContent, 0) + for fileContent := range resultCh { + files = append(files, fileContent) + } + + return files, nil +} + +func GenerateInputRefID(prefix string) string { + referenceUID, _ := uuid.NewV4() + return prefix + "/input/" + referenceUID.String() +} + +func GenerateOutputRefID(prefix string) string { + referenceUID, _ := uuid.NewV4() + return prefix + "/output/" + referenceUID.String() +} diff --git a/minio/minio_test.go b/minio/minio_test.go new file mode 100644 index 0000000..3068b12 --- /dev/null +++ b/minio/minio_test.go @@ -0,0 +1,46 @@ +package minio_test + +import ( + "context" + "encoding/json" + "testing" + + "github.com/gofrs/uuid" + "github.com/stretchr/testify/require" + + miniox "github.com/instill-ai/x/minio" +) + +func TestMinio(t *testing.T) { + t.Skipf("only for testing on local") + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + mc, err := miniox.NewMinioClientAndInitBucket(ctx, &miniox.Config{ + Host: "localhost", + Port: "19000", + RootUser: "minioadmin", + RootPwd: "minioadmin", + BucketName: "instill-ai-model", + }, nil) + + require.NoError(t, err) + + t.Log("test upload file to minio") + fileName, _ := uuid.NewV4() + uid, _ := uuid.NewV4() + + data := make(map[string]string) + data["uid"] = uid.String() + jsonBytes, _ := json.Marshal(data) + + url, stat, err := mc.UploadFile(ctx, fileName.String(), data, "application/json") + require.NoError(t, err) + t.Log("url:", url) + t.Log("size:", stat.Size) + + fileBytes, err := mc.GetFile(ctx, nil, fileName.String()) + require.NoError(t, err) + require.Equal(t, jsonBytes, fileBytes) +} diff --git a/mock/generator.go b/mock/generator.go new file mode 100644 index 0000000..0042156 --- /dev/null +++ b/mock/generator.go @@ -0,0 +1,3 @@ +package mock + +//go:generate minimock -g -i github.com/instill-ai/x/minio.MinioI -o ./ -s "_mock.gen.go" diff --git a/mock/minio_i_mock.gen.go b/mock/minio_i_mock.gen.go new file mode 100644 index 0000000..602baa6 --- /dev/null +++ b/mock/minio_i_mock.gen.go @@ -0,0 +1,1952 @@ +// Code generated by http://github.com/gojuno/minimock (v3.3.13). DO NOT EDIT. + +package mock + +import ( + "context" + "sync" + mm_atomic "sync/atomic" + mm_time "time" + + "github.com/gojuno/minimock/v3" + mm_minio "github.com/instill-ai/x/minio" + miniogo "github.com/minio/minio-go/v7" + "go.uber.org/zap" +) + +// MinioIMock implements minio.MinioI +type MinioIMock struct { + t minimock.Tester + finishOnce sync.Once + + funcDeleteFile func(ctx context.Context, logger *zap.Logger, filePath string) (err error) + inspectFuncDeleteFile func(ctx context.Context, logger *zap.Logger, filePath string) + afterDeleteFileCounter uint64 + beforeDeleteFileCounter uint64 + DeleteFileMock mMinioIMockDeleteFile + + funcGetFile func(ctx context.Context, logger *zap.Logger, filePath string) (ba1 []byte, err error) + inspectFuncGetFile func(ctx context.Context, logger *zap.Logger, filePath string) + afterGetFileCounter uint64 + beforeGetFileCounter uint64 + GetFileMock mMinioIMockGetFile + + funcGetFilesByPaths func(ctx context.Context, logger *zap.Logger, filePaths []string) (fa1 []mm_minio.FileContent, err error) + inspectFuncGetFilesByPaths func(ctx context.Context, logger *zap.Logger, filePaths []string) + afterGetFilesByPathsCounter uint64 + beforeGetFilesByPathsCounter uint64 + GetFilesByPathsMock mMinioIMockGetFilesByPaths + + funcUploadFile func(ctx context.Context, filePath string, fileContent any, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) + inspectFuncUploadFile func(ctx context.Context, filePath string, fileContent any, fileMimeType string) + afterUploadFileCounter uint64 + beforeUploadFileCounter uint64 + UploadFileMock mMinioIMockUploadFile + + funcUploadFileBytes func(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) + inspectFuncUploadFileBytes func(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) + afterUploadFileBytesCounter uint64 + beforeUploadFileBytesCounter uint64 + UploadFileBytesMock mMinioIMockUploadFileBytes +} + +// NewMinioIMock returns a mock for minio.MinioI +func NewMinioIMock(t minimock.Tester) *MinioIMock { + m := &MinioIMock{t: t} + + if controller, ok := t.(minimock.MockController); ok { + controller.RegisterMocker(m) + } + + m.DeleteFileMock = mMinioIMockDeleteFile{mock: m} + m.DeleteFileMock.callArgs = []*MinioIMockDeleteFileParams{} + + m.GetFileMock = mMinioIMockGetFile{mock: m} + m.GetFileMock.callArgs = []*MinioIMockGetFileParams{} + + m.GetFilesByPathsMock = mMinioIMockGetFilesByPaths{mock: m} + m.GetFilesByPathsMock.callArgs = []*MinioIMockGetFilesByPathsParams{} + + m.UploadFileMock = mMinioIMockUploadFile{mock: m} + m.UploadFileMock.callArgs = []*MinioIMockUploadFileParams{} + + m.UploadFileBytesMock = mMinioIMockUploadFileBytes{mock: m} + m.UploadFileBytesMock.callArgs = []*MinioIMockUploadFileBytesParams{} + + t.Cleanup(m.MinimockFinish) + + return m +} + +type mMinioIMockDeleteFile struct { + optional bool + mock *MinioIMock + defaultExpectation *MinioIMockDeleteFileExpectation + expectations []*MinioIMockDeleteFileExpectation + + callArgs []*MinioIMockDeleteFileParams + mutex sync.RWMutex + + expectedInvocations uint64 +} + +// MinioIMockDeleteFileExpectation specifies expectation struct of the MinioI.DeleteFile +type MinioIMockDeleteFileExpectation struct { + mock *MinioIMock + params *MinioIMockDeleteFileParams + paramPtrs *MinioIMockDeleteFileParamPtrs + results *MinioIMockDeleteFileResults + Counter uint64 +} + +// MinioIMockDeleteFileParams contains parameters of the MinioI.DeleteFile +type MinioIMockDeleteFileParams struct { + ctx context.Context + logger *zap.Logger + filePath string +} + +// MinioIMockDeleteFileParamPtrs contains pointers to parameters of the MinioI.DeleteFile +type MinioIMockDeleteFileParamPtrs struct { + ctx *context.Context + logger **zap.Logger + filePath *string +} + +// MinioIMockDeleteFileResults contains results of the MinioI.DeleteFile +type MinioIMockDeleteFileResults struct { + err error +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmDeleteFile *mMinioIMockDeleteFile) Optional() *mMinioIMockDeleteFile { + mmDeleteFile.optional = true + return mmDeleteFile +} + +// Expect sets up expected params for MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) Expect(ctx context.Context, logger *zap.Logger, filePath string) *mMinioIMockDeleteFile { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + if mmDeleteFile.defaultExpectation == nil { + mmDeleteFile.defaultExpectation = &MinioIMockDeleteFileExpectation{} + } + + if mmDeleteFile.defaultExpectation.paramPtrs != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by ExpectParams functions") + } + + mmDeleteFile.defaultExpectation.params = &MinioIMockDeleteFileParams{ctx, logger, filePath} + for _, e := range mmDeleteFile.expectations { + if minimock.Equal(e.params, mmDeleteFile.defaultExpectation.params) { + mmDeleteFile.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteFile.defaultExpectation.params) + } + } + + return mmDeleteFile +} + +// ExpectCtxParam1 sets up expected param ctx for MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) ExpectCtxParam1(ctx context.Context) *mMinioIMockDeleteFile { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + if mmDeleteFile.defaultExpectation == nil { + mmDeleteFile.defaultExpectation = &MinioIMockDeleteFileExpectation{} + } + + if mmDeleteFile.defaultExpectation.params != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Expect") + } + + if mmDeleteFile.defaultExpectation.paramPtrs == nil { + mmDeleteFile.defaultExpectation.paramPtrs = &MinioIMockDeleteFileParamPtrs{} + } + mmDeleteFile.defaultExpectation.paramPtrs.ctx = &ctx + + return mmDeleteFile +} + +// ExpectLoggerParam2 sets up expected param logger for MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) ExpectLoggerParam2(logger *zap.Logger) *mMinioIMockDeleteFile { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + if mmDeleteFile.defaultExpectation == nil { + mmDeleteFile.defaultExpectation = &MinioIMockDeleteFileExpectation{} + } + + if mmDeleteFile.defaultExpectation.params != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Expect") + } + + if mmDeleteFile.defaultExpectation.paramPtrs == nil { + mmDeleteFile.defaultExpectation.paramPtrs = &MinioIMockDeleteFileParamPtrs{} + } + mmDeleteFile.defaultExpectation.paramPtrs.logger = &logger + + return mmDeleteFile +} + +// ExpectFilePathParam3 sets up expected param filePath for MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) ExpectFilePathParam3(filePath string) *mMinioIMockDeleteFile { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + if mmDeleteFile.defaultExpectation == nil { + mmDeleteFile.defaultExpectation = &MinioIMockDeleteFileExpectation{} + } + + if mmDeleteFile.defaultExpectation.params != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Expect") + } + + if mmDeleteFile.defaultExpectation.paramPtrs == nil { + mmDeleteFile.defaultExpectation.paramPtrs = &MinioIMockDeleteFileParamPtrs{} + } + mmDeleteFile.defaultExpectation.paramPtrs.filePath = &filePath + + return mmDeleteFile +} + +// Inspect accepts an inspector function that has same arguments as the MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) Inspect(f func(ctx context.Context, logger *zap.Logger, filePath string)) *mMinioIMockDeleteFile { + if mmDeleteFile.mock.inspectFuncDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("Inspect function is already set for MinioIMock.DeleteFile") + } + + mmDeleteFile.mock.inspectFuncDeleteFile = f + + return mmDeleteFile +} + +// Return sets up results that will be returned by MinioI.DeleteFile +func (mmDeleteFile *mMinioIMockDeleteFile) Return(err error) *MinioIMock { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + if mmDeleteFile.defaultExpectation == nil { + mmDeleteFile.defaultExpectation = &MinioIMockDeleteFileExpectation{mock: mmDeleteFile.mock} + } + mmDeleteFile.defaultExpectation.results = &MinioIMockDeleteFileResults{err} + return mmDeleteFile.mock +} + +// Set uses given function f to mock the MinioI.DeleteFile method +func (mmDeleteFile *mMinioIMockDeleteFile) Set(f func(ctx context.Context, logger *zap.Logger, filePath string) (err error)) *MinioIMock { + if mmDeleteFile.defaultExpectation != nil { + mmDeleteFile.mock.t.Fatalf("Default expectation is already set for the MinioI.DeleteFile method") + } + + if len(mmDeleteFile.expectations) > 0 { + mmDeleteFile.mock.t.Fatalf("Some expectations are already set for the MinioI.DeleteFile method") + } + + mmDeleteFile.mock.funcDeleteFile = f + return mmDeleteFile.mock +} + +// When sets expectation for the MinioI.DeleteFile which will trigger the result defined by the following +// Then helper +func (mmDeleteFile *mMinioIMockDeleteFile) When(ctx context.Context, logger *zap.Logger, filePath string) *MinioIMockDeleteFileExpectation { + if mmDeleteFile.mock.funcDeleteFile != nil { + mmDeleteFile.mock.t.Fatalf("MinioIMock.DeleteFile mock is already set by Set") + } + + expectation := &MinioIMockDeleteFileExpectation{ + mock: mmDeleteFile.mock, + params: &MinioIMockDeleteFileParams{ctx, logger, filePath}, + } + mmDeleteFile.expectations = append(mmDeleteFile.expectations, expectation) + return expectation +} + +// Then sets up MinioI.DeleteFile return parameters for the expectation previously defined by the When method +func (e *MinioIMockDeleteFileExpectation) Then(err error) *MinioIMock { + e.results = &MinioIMockDeleteFileResults{err} + return e.mock +} + +// Times sets number of times MinioI.DeleteFile should be invoked +func (mmDeleteFile *mMinioIMockDeleteFile) Times(n uint64) *mMinioIMockDeleteFile { + if n == 0 { + mmDeleteFile.mock.t.Fatalf("Times of MinioIMock.DeleteFile mock can not be zero") + } + mm_atomic.StoreUint64(&mmDeleteFile.expectedInvocations, n) + return mmDeleteFile +} + +func (mmDeleteFile *mMinioIMockDeleteFile) invocationsDone() bool { + if len(mmDeleteFile.expectations) == 0 && mmDeleteFile.defaultExpectation == nil && mmDeleteFile.mock.funcDeleteFile == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmDeleteFile.mock.afterDeleteFileCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteFile.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// DeleteFile implements minio.MinioI +func (mmDeleteFile *MinioIMock) DeleteFile(ctx context.Context, logger *zap.Logger, filePath string) (err error) { + mm_atomic.AddUint64(&mmDeleteFile.beforeDeleteFileCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteFile.afterDeleteFileCounter, 1) + + if mmDeleteFile.inspectFuncDeleteFile != nil { + mmDeleteFile.inspectFuncDeleteFile(ctx, logger, filePath) + } + + mm_params := MinioIMockDeleteFileParams{ctx, logger, filePath} + + // Record call args + mmDeleteFile.DeleteFileMock.mutex.Lock() + mmDeleteFile.DeleteFileMock.callArgs = append(mmDeleteFile.DeleteFileMock.callArgs, &mm_params) + mmDeleteFile.DeleteFileMock.mutex.Unlock() + + for _, e := range mmDeleteFile.DeleteFileMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.err + } + } + + if mmDeleteFile.DeleteFileMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteFile.DeleteFileMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteFile.DeleteFileMock.defaultExpectation.params + mm_want_ptrs := mmDeleteFile.DeleteFileMock.defaultExpectation.paramPtrs + + mm_got := MinioIMockDeleteFileParams{ctx, logger, filePath} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmDeleteFile.t.Errorf("MinioIMock.DeleteFile got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.logger != nil && !minimock.Equal(*mm_want_ptrs.logger, mm_got.logger) { + mmDeleteFile.t.Errorf("MinioIMock.DeleteFile got unexpected parameter logger, want: %#v, got: %#v%s\n", *mm_want_ptrs.logger, mm_got.logger, minimock.Diff(*mm_want_ptrs.logger, mm_got.logger)) + } + + if mm_want_ptrs.filePath != nil && !minimock.Equal(*mm_want_ptrs.filePath, mm_got.filePath) { + mmDeleteFile.t.Errorf("MinioIMock.DeleteFile got unexpected parameter filePath, want: %#v, got: %#v%s\n", *mm_want_ptrs.filePath, mm_got.filePath, minimock.Diff(*mm_want_ptrs.filePath, mm_got.filePath)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmDeleteFile.t.Errorf("MinioIMock.DeleteFile got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmDeleteFile.DeleteFileMock.defaultExpectation.results + if mm_results == nil { + mmDeleteFile.t.Fatal("No results are set for the MinioIMock.DeleteFile") + } + return (*mm_results).err + } + if mmDeleteFile.funcDeleteFile != nil { + return mmDeleteFile.funcDeleteFile(ctx, logger, filePath) + } + mmDeleteFile.t.Fatalf("Unexpected call to MinioIMock.DeleteFile. %v %v %v", ctx, logger, filePath) + return +} + +// DeleteFileAfterCounter returns a count of finished MinioIMock.DeleteFile invocations +func (mmDeleteFile *MinioIMock) DeleteFileAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteFile.afterDeleteFileCounter) +} + +// DeleteFileBeforeCounter returns a count of MinioIMock.DeleteFile invocations +func (mmDeleteFile *MinioIMock) DeleteFileBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteFile.beforeDeleteFileCounter) +} + +// Calls returns a list of arguments used in each call to MinioIMock.DeleteFile. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmDeleteFile *mMinioIMockDeleteFile) Calls() []*MinioIMockDeleteFileParams { + mmDeleteFile.mutex.RLock() + + argCopy := make([]*MinioIMockDeleteFileParams, len(mmDeleteFile.callArgs)) + copy(argCopy, mmDeleteFile.callArgs) + + mmDeleteFile.mutex.RUnlock() + + return argCopy +} + +// MinimockDeleteFileDone returns true if the count of the DeleteFile invocations corresponds +// the number of defined expectations +func (m *MinioIMock) MinimockDeleteFileDone() bool { + if m.DeleteFileMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.DeleteFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.DeleteFileMock.invocationsDone() +} + +// MinimockDeleteFileInspect logs each unmet expectation +func (m *MinioIMock) MinimockDeleteFileInspect() { + for _, e := range m.DeleteFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to MinioIMock.DeleteFile with params: %#v", *e.params) + } + } + + afterDeleteFileCounter := mm_atomic.LoadUint64(&m.afterDeleteFileCounter) + // if default expectation was set then invocations count should be greater than zero + if m.DeleteFileMock.defaultExpectation != nil && afterDeleteFileCounter < 1 { + if m.DeleteFileMock.defaultExpectation.params == nil { + m.t.Error("Expected call to MinioIMock.DeleteFile") + } else { + m.t.Errorf("Expected call to MinioIMock.DeleteFile with params: %#v", *m.DeleteFileMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcDeleteFile != nil && afterDeleteFileCounter < 1 { + m.t.Error("Expected call to MinioIMock.DeleteFile") + } + + if !m.DeleteFileMock.invocationsDone() && afterDeleteFileCounter > 0 { + m.t.Errorf("Expected %d calls to MinioIMock.DeleteFile but found %d calls", + mm_atomic.LoadUint64(&m.DeleteFileMock.expectedInvocations), afterDeleteFileCounter) + } +} + +type mMinioIMockGetFile struct { + optional bool + mock *MinioIMock + defaultExpectation *MinioIMockGetFileExpectation + expectations []*MinioIMockGetFileExpectation + + callArgs []*MinioIMockGetFileParams + mutex sync.RWMutex + + expectedInvocations uint64 +} + +// MinioIMockGetFileExpectation specifies expectation struct of the MinioI.GetFile +type MinioIMockGetFileExpectation struct { + mock *MinioIMock + params *MinioIMockGetFileParams + paramPtrs *MinioIMockGetFileParamPtrs + results *MinioIMockGetFileResults + Counter uint64 +} + +// MinioIMockGetFileParams contains parameters of the MinioI.GetFile +type MinioIMockGetFileParams struct { + ctx context.Context + logger *zap.Logger + filePath string +} + +// MinioIMockGetFileParamPtrs contains pointers to parameters of the MinioI.GetFile +type MinioIMockGetFileParamPtrs struct { + ctx *context.Context + logger **zap.Logger + filePath *string +} + +// MinioIMockGetFileResults contains results of the MinioI.GetFile +type MinioIMockGetFileResults struct { + ba1 []byte + err error +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmGetFile *mMinioIMockGetFile) Optional() *mMinioIMockGetFile { + mmGetFile.optional = true + return mmGetFile +} + +// Expect sets up expected params for MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) Expect(ctx context.Context, logger *zap.Logger, filePath string) *mMinioIMockGetFile { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + if mmGetFile.defaultExpectation == nil { + mmGetFile.defaultExpectation = &MinioIMockGetFileExpectation{} + } + + if mmGetFile.defaultExpectation.paramPtrs != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by ExpectParams functions") + } + + mmGetFile.defaultExpectation.params = &MinioIMockGetFileParams{ctx, logger, filePath} + for _, e := range mmGetFile.expectations { + if minimock.Equal(e.params, mmGetFile.defaultExpectation.params) { + mmGetFile.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetFile.defaultExpectation.params) + } + } + + return mmGetFile +} + +// ExpectCtxParam1 sets up expected param ctx for MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) ExpectCtxParam1(ctx context.Context) *mMinioIMockGetFile { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + if mmGetFile.defaultExpectation == nil { + mmGetFile.defaultExpectation = &MinioIMockGetFileExpectation{} + } + + if mmGetFile.defaultExpectation.params != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Expect") + } + + if mmGetFile.defaultExpectation.paramPtrs == nil { + mmGetFile.defaultExpectation.paramPtrs = &MinioIMockGetFileParamPtrs{} + } + mmGetFile.defaultExpectation.paramPtrs.ctx = &ctx + + return mmGetFile +} + +// ExpectLoggerParam2 sets up expected param logger for MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) ExpectLoggerParam2(logger *zap.Logger) *mMinioIMockGetFile { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + if mmGetFile.defaultExpectation == nil { + mmGetFile.defaultExpectation = &MinioIMockGetFileExpectation{} + } + + if mmGetFile.defaultExpectation.params != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Expect") + } + + if mmGetFile.defaultExpectation.paramPtrs == nil { + mmGetFile.defaultExpectation.paramPtrs = &MinioIMockGetFileParamPtrs{} + } + mmGetFile.defaultExpectation.paramPtrs.logger = &logger + + return mmGetFile +} + +// ExpectFilePathParam3 sets up expected param filePath for MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) ExpectFilePathParam3(filePath string) *mMinioIMockGetFile { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + if mmGetFile.defaultExpectation == nil { + mmGetFile.defaultExpectation = &MinioIMockGetFileExpectation{} + } + + if mmGetFile.defaultExpectation.params != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Expect") + } + + if mmGetFile.defaultExpectation.paramPtrs == nil { + mmGetFile.defaultExpectation.paramPtrs = &MinioIMockGetFileParamPtrs{} + } + mmGetFile.defaultExpectation.paramPtrs.filePath = &filePath + + return mmGetFile +} + +// Inspect accepts an inspector function that has same arguments as the MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) Inspect(f func(ctx context.Context, logger *zap.Logger, filePath string)) *mMinioIMockGetFile { + if mmGetFile.mock.inspectFuncGetFile != nil { + mmGetFile.mock.t.Fatalf("Inspect function is already set for MinioIMock.GetFile") + } + + mmGetFile.mock.inspectFuncGetFile = f + + return mmGetFile +} + +// Return sets up results that will be returned by MinioI.GetFile +func (mmGetFile *mMinioIMockGetFile) Return(ba1 []byte, err error) *MinioIMock { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + if mmGetFile.defaultExpectation == nil { + mmGetFile.defaultExpectation = &MinioIMockGetFileExpectation{mock: mmGetFile.mock} + } + mmGetFile.defaultExpectation.results = &MinioIMockGetFileResults{ba1, err} + return mmGetFile.mock +} + +// Set uses given function f to mock the MinioI.GetFile method +func (mmGetFile *mMinioIMockGetFile) Set(f func(ctx context.Context, logger *zap.Logger, filePath string) (ba1 []byte, err error)) *MinioIMock { + if mmGetFile.defaultExpectation != nil { + mmGetFile.mock.t.Fatalf("Default expectation is already set for the MinioI.GetFile method") + } + + if len(mmGetFile.expectations) > 0 { + mmGetFile.mock.t.Fatalf("Some expectations are already set for the MinioI.GetFile method") + } + + mmGetFile.mock.funcGetFile = f + return mmGetFile.mock +} + +// When sets expectation for the MinioI.GetFile which will trigger the result defined by the following +// Then helper +func (mmGetFile *mMinioIMockGetFile) When(ctx context.Context, logger *zap.Logger, filePath string) *MinioIMockGetFileExpectation { + if mmGetFile.mock.funcGetFile != nil { + mmGetFile.mock.t.Fatalf("MinioIMock.GetFile mock is already set by Set") + } + + expectation := &MinioIMockGetFileExpectation{ + mock: mmGetFile.mock, + params: &MinioIMockGetFileParams{ctx, logger, filePath}, + } + mmGetFile.expectations = append(mmGetFile.expectations, expectation) + return expectation +} + +// Then sets up MinioI.GetFile return parameters for the expectation previously defined by the When method +func (e *MinioIMockGetFileExpectation) Then(ba1 []byte, err error) *MinioIMock { + e.results = &MinioIMockGetFileResults{ba1, err} + return e.mock +} + +// Times sets number of times MinioI.GetFile should be invoked +func (mmGetFile *mMinioIMockGetFile) Times(n uint64) *mMinioIMockGetFile { + if n == 0 { + mmGetFile.mock.t.Fatalf("Times of MinioIMock.GetFile mock can not be zero") + } + mm_atomic.StoreUint64(&mmGetFile.expectedInvocations, n) + return mmGetFile +} + +func (mmGetFile *mMinioIMockGetFile) invocationsDone() bool { + if len(mmGetFile.expectations) == 0 && mmGetFile.defaultExpectation == nil && mmGetFile.mock.funcGetFile == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmGetFile.mock.afterGetFileCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetFile.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// GetFile implements minio.MinioI +func (mmGetFile *MinioIMock) GetFile(ctx context.Context, logger *zap.Logger, filePath string) (ba1 []byte, err error) { + mm_atomic.AddUint64(&mmGetFile.beforeGetFileCounter, 1) + defer mm_atomic.AddUint64(&mmGetFile.afterGetFileCounter, 1) + + if mmGetFile.inspectFuncGetFile != nil { + mmGetFile.inspectFuncGetFile(ctx, logger, filePath) + } + + mm_params := MinioIMockGetFileParams{ctx, logger, filePath} + + // Record call args + mmGetFile.GetFileMock.mutex.Lock() + mmGetFile.GetFileMock.callArgs = append(mmGetFile.GetFileMock.callArgs, &mm_params) + mmGetFile.GetFileMock.mutex.Unlock() + + for _, e := range mmGetFile.GetFileMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.ba1, e.results.err + } + } + + if mmGetFile.GetFileMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetFile.GetFileMock.defaultExpectation.Counter, 1) + mm_want := mmGetFile.GetFileMock.defaultExpectation.params + mm_want_ptrs := mmGetFile.GetFileMock.defaultExpectation.paramPtrs + + mm_got := MinioIMockGetFileParams{ctx, logger, filePath} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmGetFile.t.Errorf("MinioIMock.GetFile got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.logger != nil && !minimock.Equal(*mm_want_ptrs.logger, mm_got.logger) { + mmGetFile.t.Errorf("MinioIMock.GetFile got unexpected parameter logger, want: %#v, got: %#v%s\n", *mm_want_ptrs.logger, mm_got.logger, minimock.Diff(*mm_want_ptrs.logger, mm_got.logger)) + } + + if mm_want_ptrs.filePath != nil && !minimock.Equal(*mm_want_ptrs.filePath, mm_got.filePath) { + mmGetFile.t.Errorf("MinioIMock.GetFile got unexpected parameter filePath, want: %#v, got: %#v%s\n", *mm_want_ptrs.filePath, mm_got.filePath, minimock.Diff(*mm_want_ptrs.filePath, mm_got.filePath)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmGetFile.t.Errorf("MinioIMock.GetFile got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmGetFile.GetFileMock.defaultExpectation.results + if mm_results == nil { + mmGetFile.t.Fatal("No results are set for the MinioIMock.GetFile") + } + return (*mm_results).ba1, (*mm_results).err + } + if mmGetFile.funcGetFile != nil { + return mmGetFile.funcGetFile(ctx, logger, filePath) + } + mmGetFile.t.Fatalf("Unexpected call to MinioIMock.GetFile. %v %v %v", ctx, logger, filePath) + return +} + +// GetFileAfterCounter returns a count of finished MinioIMock.GetFile invocations +func (mmGetFile *MinioIMock) GetFileAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetFile.afterGetFileCounter) +} + +// GetFileBeforeCounter returns a count of MinioIMock.GetFile invocations +func (mmGetFile *MinioIMock) GetFileBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetFile.beforeGetFileCounter) +} + +// Calls returns a list of arguments used in each call to MinioIMock.GetFile. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmGetFile *mMinioIMockGetFile) Calls() []*MinioIMockGetFileParams { + mmGetFile.mutex.RLock() + + argCopy := make([]*MinioIMockGetFileParams, len(mmGetFile.callArgs)) + copy(argCopy, mmGetFile.callArgs) + + mmGetFile.mutex.RUnlock() + + return argCopy +} + +// MinimockGetFileDone returns true if the count of the GetFile invocations corresponds +// the number of defined expectations +func (m *MinioIMock) MinimockGetFileDone() bool { + if m.GetFileMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.GetFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.GetFileMock.invocationsDone() +} + +// MinimockGetFileInspect logs each unmet expectation +func (m *MinioIMock) MinimockGetFileInspect() { + for _, e := range m.GetFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to MinioIMock.GetFile with params: %#v", *e.params) + } + } + + afterGetFileCounter := mm_atomic.LoadUint64(&m.afterGetFileCounter) + // if default expectation was set then invocations count should be greater than zero + if m.GetFileMock.defaultExpectation != nil && afterGetFileCounter < 1 { + if m.GetFileMock.defaultExpectation.params == nil { + m.t.Error("Expected call to MinioIMock.GetFile") + } else { + m.t.Errorf("Expected call to MinioIMock.GetFile with params: %#v", *m.GetFileMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcGetFile != nil && afterGetFileCounter < 1 { + m.t.Error("Expected call to MinioIMock.GetFile") + } + + if !m.GetFileMock.invocationsDone() && afterGetFileCounter > 0 { + m.t.Errorf("Expected %d calls to MinioIMock.GetFile but found %d calls", + mm_atomic.LoadUint64(&m.GetFileMock.expectedInvocations), afterGetFileCounter) + } +} + +type mMinioIMockGetFilesByPaths struct { + optional bool + mock *MinioIMock + defaultExpectation *MinioIMockGetFilesByPathsExpectation + expectations []*MinioIMockGetFilesByPathsExpectation + + callArgs []*MinioIMockGetFilesByPathsParams + mutex sync.RWMutex + + expectedInvocations uint64 +} + +// MinioIMockGetFilesByPathsExpectation specifies expectation struct of the MinioI.GetFilesByPaths +type MinioIMockGetFilesByPathsExpectation struct { + mock *MinioIMock + params *MinioIMockGetFilesByPathsParams + paramPtrs *MinioIMockGetFilesByPathsParamPtrs + results *MinioIMockGetFilesByPathsResults + Counter uint64 +} + +// MinioIMockGetFilesByPathsParams contains parameters of the MinioI.GetFilesByPaths +type MinioIMockGetFilesByPathsParams struct { + ctx context.Context + logger *zap.Logger + filePaths []string +} + +// MinioIMockGetFilesByPathsParamPtrs contains pointers to parameters of the MinioI.GetFilesByPaths +type MinioIMockGetFilesByPathsParamPtrs struct { + ctx *context.Context + logger **zap.Logger + filePaths *[]string +} + +// MinioIMockGetFilesByPathsResults contains results of the MinioI.GetFilesByPaths +type MinioIMockGetFilesByPathsResults struct { + fa1 []mm_minio.FileContent + err error +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Optional() *mMinioIMockGetFilesByPaths { + mmGetFilesByPaths.optional = true + return mmGetFilesByPaths +} + +// Expect sets up expected params for MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Expect(ctx context.Context, logger *zap.Logger, filePaths []string) *mMinioIMockGetFilesByPaths { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + if mmGetFilesByPaths.defaultExpectation == nil { + mmGetFilesByPaths.defaultExpectation = &MinioIMockGetFilesByPathsExpectation{} + } + + if mmGetFilesByPaths.defaultExpectation.paramPtrs != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by ExpectParams functions") + } + + mmGetFilesByPaths.defaultExpectation.params = &MinioIMockGetFilesByPathsParams{ctx, logger, filePaths} + for _, e := range mmGetFilesByPaths.expectations { + if minimock.Equal(e.params, mmGetFilesByPaths.defaultExpectation.params) { + mmGetFilesByPaths.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetFilesByPaths.defaultExpectation.params) + } + } + + return mmGetFilesByPaths +} + +// ExpectCtxParam1 sets up expected param ctx for MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) ExpectCtxParam1(ctx context.Context) *mMinioIMockGetFilesByPaths { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + if mmGetFilesByPaths.defaultExpectation == nil { + mmGetFilesByPaths.defaultExpectation = &MinioIMockGetFilesByPathsExpectation{} + } + + if mmGetFilesByPaths.defaultExpectation.params != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Expect") + } + + if mmGetFilesByPaths.defaultExpectation.paramPtrs == nil { + mmGetFilesByPaths.defaultExpectation.paramPtrs = &MinioIMockGetFilesByPathsParamPtrs{} + } + mmGetFilesByPaths.defaultExpectation.paramPtrs.ctx = &ctx + + return mmGetFilesByPaths +} + +// ExpectLoggerParam2 sets up expected param logger for MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) ExpectLoggerParam2(logger *zap.Logger) *mMinioIMockGetFilesByPaths { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + if mmGetFilesByPaths.defaultExpectation == nil { + mmGetFilesByPaths.defaultExpectation = &MinioIMockGetFilesByPathsExpectation{} + } + + if mmGetFilesByPaths.defaultExpectation.params != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Expect") + } + + if mmGetFilesByPaths.defaultExpectation.paramPtrs == nil { + mmGetFilesByPaths.defaultExpectation.paramPtrs = &MinioIMockGetFilesByPathsParamPtrs{} + } + mmGetFilesByPaths.defaultExpectation.paramPtrs.logger = &logger + + return mmGetFilesByPaths +} + +// ExpectFilePathsParam3 sets up expected param filePaths for MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) ExpectFilePathsParam3(filePaths []string) *mMinioIMockGetFilesByPaths { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + if mmGetFilesByPaths.defaultExpectation == nil { + mmGetFilesByPaths.defaultExpectation = &MinioIMockGetFilesByPathsExpectation{} + } + + if mmGetFilesByPaths.defaultExpectation.params != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Expect") + } + + if mmGetFilesByPaths.defaultExpectation.paramPtrs == nil { + mmGetFilesByPaths.defaultExpectation.paramPtrs = &MinioIMockGetFilesByPathsParamPtrs{} + } + mmGetFilesByPaths.defaultExpectation.paramPtrs.filePaths = &filePaths + + return mmGetFilesByPaths +} + +// Inspect accepts an inspector function that has same arguments as the MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Inspect(f func(ctx context.Context, logger *zap.Logger, filePaths []string)) *mMinioIMockGetFilesByPaths { + if mmGetFilesByPaths.mock.inspectFuncGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("Inspect function is already set for MinioIMock.GetFilesByPaths") + } + + mmGetFilesByPaths.mock.inspectFuncGetFilesByPaths = f + + return mmGetFilesByPaths +} + +// Return sets up results that will be returned by MinioI.GetFilesByPaths +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Return(fa1 []mm_minio.FileContent, err error) *MinioIMock { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + if mmGetFilesByPaths.defaultExpectation == nil { + mmGetFilesByPaths.defaultExpectation = &MinioIMockGetFilesByPathsExpectation{mock: mmGetFilesByPaths.mock} + } + mmGetFilesByPaths.defaultExpectation.results = &MinioIMockGetFilesByPathsResults{fa1, err} + return mmGetFilesByPaths.mock +} + +// Set uses given function f to mock the MinioI.GetFilesByPaths method +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Set(f func(ctx context.Context, logger *zap.Logger, filePaths []string) (fa1 []mm_minio.FileContent, err error)) *MinioIMock { + if mmGetFilesByPaths.defaultExpectation != nil { + mmGetFilesByPaths.mock.t.Fatalf("Default expectation is already set for the MinioI.GetFilesByPaths method") + } + + if len(mmGetFilesByPaths.expectations) > 0 { + mmGetFilesByPaths.mock.t.Fatalf("Some expectations are already set for the MinioI.GetFilesByPaths method") + } + + mmGetFilesByPaths.mock.funcGetFilesByPaths = f + return mmGetFilesByPaths.mock +} + +// When sets expectation for the MinioI.GetFilesByPaths which will trigger the result defined by the following +// Then helper +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) When(ctx context.Context, logger *zap.Logger, filePaths []string) *MinioIMockGetFilesByPathsExpectation { + if mmGetFilesByPaths.mock.funcGetFilesByPaths != nil { + mmGetFilesByPaths.mock.t.Fatalf("MinioIMock.GetFilesByPaths mock is already set by Set") + } + + expectation := &MinioIMockGetFilesByPathsExpectation{ + mock: mmGetFilesByPaths.mock, + params: &MinioIMockGetFilesByPathsParams{ctx, logger, filePaths}, + } + mmGetFilesByPaths.expectations = append(mmGetFilesByPaths.expectations, expectation) + return expectation +} + +// Then sets up MinioI.GetFilesByPaths return parameters for the expectation previously defined by the When method +func (e *MinioIMockGetFilesByPathsExpectation) Then(fa1 []mm_minio.FileContent, err error) *MinioIMock { + e.results = &MinioIMockGetFilesByPathsResults{fa1, err} + return e.mock +} + +// Times sets number of times MinioI.GetFilesByPaths should be invoked +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Times(n uint64) *mMinioIMockGetFilesByPaths { + if n == 0 { + mmGetFilesByPaths.mock.t.Fatalf("Times of MinioIMock.GetFilesByPaths mock can not be zero") + } + mm_atomic.StoreUint64(&mmGetFilesByPaths.expectedInvocations, n) + return mmGetFilesByPaths +} + +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) invocationsDone() bool { + if len(mmGetFilesByPaths.expectations) == 0 && mmGetFilesByPaths.defaultExpectation == nil && mmGetFilesByPaths.mock.funcGetFilesByPaths == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmGetFilesByPaths.mock.afterGetFilesByPathsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetFilesByPaths.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// GetFilesByPaths implements minio.MinioI +func (mmGetFilesByPaths *MinioIMock) GetFilesByPaths(ctx context.Context, logger *zap.Logger, filePaths []string) (fa1 []mm_minio.FileContent, err error) { + mm_atomic.AddUint64(&mmGetFilesByPaths.beforeGetFilesByPathsCounter, 1) + defer mm_atomic.AddUint64(&mmGetFilesByPaths.afterGetFilesByPathsCounter, 1) + + if mmGetFilesByPaths.inspectFuncGetFilesByPaths != nil { + mmGetFilesByPaths.inspectFuncGetFilesByPaths(ctx, logger, filePaths) + } + + mm_params := MinioIMockGetFilesByPathsParams{ctx, logger, filePaths} + + // Record call args + mmGetFilesByPaths.GetFilesByPathsMock.mutex.Lock() + mmGetFilesByPaths.GetFilesByPathsMock.callArgs = append(mmGetFilesByPaths.GetFilesByPathsMock.callArgs, &mm_params) + mmGetFilesByPaths.GetFilesByPathsMock.mutex.Unlock() + + for _, e := range mmGetFilesByPaths.GetFilesByPathsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.fa1, e.results.err + } + } + + if mmGetFilesByPaths.GetFilesByPathsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetFilesByPaths.GetFilesByPathsMock.defaultExpectation.Counter, 1) + mm_want := mmGetFilesByPaths.GetFilesByPathsMock.defaultExpectation.params + mm_want_ptrs := mmGetFilesByPaths.GetFilesByPathsMock.defaultExpectation.paramPtrs + + mm_got := MinioIMockGetFilesByPathsParams{ctx, logger, filePaths} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmGetFilesByPaths.t.Errorf("MinioIMock.GetFilesByPaths got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.logger != nil && !minimock.Equal(*mm_want_ptrs.logger, mm_got.logger) { + mmGetFilesByPaths.t.Errorf("MinioIMock.GetFilesByPaths got unexpected parameter logger, want: %#v, got: %#v%s\n", *mm_want_ptrs.logger, mm_got.logger, minimock.Diff(*mm_want_ptrs.logger, mm_got.logger)) + } + + if mm_want_ptrs.filePaths != nil && !minimock.Equal(*mm_want_ptrs.filePaths, mm_got.filePaths) { + mmGetFilesByPaths.t.Errorf("MinioIMock.GetFilesByPaths got unexpected parameter filePaths, want: %#v, got: %#v%s\n", *mm_want_ptrs.filePaths, mm_got.filePaths, minimock.Diff(*mm_want_ptrs.filePaths, mm_got.filePaths)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmGetFilesByPaths.t.Errorf("MinioIMock.GetFilesByPaths got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmGetFilesByPaths.GetFilesByPathsMock.defaultExpectation.results + if mm_results == nil { + mmGetFilesByPaths.t.Fatal("No results are set for the MinioIMock.GetFilesByPaths") + } + return (*mm_results).fa1, (*mm_results).err + } + if mmGetFilesByPaths.funcGetFilesByPaths != nil { + return mmGetFilesByPaths.funcGetFilesByPaths(ctx, logger, filePaths) + } + mmGetFilesByPaths.t.Fatalf("Unexpected call to MinioIMock.GetFilesByPaths. %v %v %v", ctx, logger, filePaths) + return +} + +// GetFilesByPathsAfterCounter returns a count of finished MinioIMock.GetFilesByPaths invocations +func (mmGetFilesByPaths *MinioIMock) GetFilesByPathsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetFilesByPaths.afterGetFilesByPathsCounter) +} + +// GetFilesByPathsBeforeCounter returns a count of MinioIMock.GetFilesByPaths invocations +func (mmGetFilesByPaths *MinioIMock) GetFilesByPathsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetFilesByPaths.beforeGetFilesByPathsCounter) +} + +// Calls returns a list of arguments used in each call to MinioIMock.GetFilesByPaths. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmGetFilesByPaths *mMinioIMockGetFilesByPaths) Calls() []*MinioIMockGetFilesByPathsParams { + mmGetFilesByPaths.mutex.RLock() + + argCopy := make([]*MinioIMockGetFilesByPathsParams, len(mmGetFilesByPaths.callArgs)) + copy(argCopy, mmGetFilesByPaths.callArgs) + + mmGetFilesByPaths.mutex.RUnlock() + + return argCopy +} + +// MinimockGetFilesByPathsDone returns true if the count of the GetFilesByPaths invocations corresponds +// the number of defined expectations +func (m *MinioIMock) MinimockGetFilesByPathsDone() bool { + if m.GetFilesByPathsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.GetFilesByPathsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.GetFilesByPathsMock.invocationsDone() +} + +// MinimockGetFilesByPathsInspect logs each unmet expectation +func (m *MinioIMock) MinimockGetFilesByPathsInspect() { + for _, e := range m.GetFilesByPathsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to MinioIMock.GetFilesByPaths with params: %#v", *e.params) + } + } + + afterGetFilesByPathsCounter := mm_atomic.LoadUint64(&m.afterGetFilesByPathsCounter) + // if default expectation was set then invocations count should be greater than zero + if m.GetFilesByPathsMock.defaultExpectation != nil && afterGetFilesByPathsCounter < 1 { + if m.GetFilesByPathsMock.defaultExpectation.params == nil { + m.t.Error("Expected call to MinioIMock.GetFilesByPaths") + } else { + m.t.Errorf("Expected call to MinioIMock.GetFilesByPaths with params: %#v", *m.GetFilesByPathsMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcGetFilesByPaths != nil && afterGetFilesByPathsCounter < 1 { + m.t.Error("Expected call to MinioIMock.GetFilesByPaths") + } + + if !m.GetFilesByPathsMock.invocationsDone() && afterGetFilesByPathsCounter > 0 { + m.t.Errorf("Expected %d calls to MinioIMock.GetFilesByPaths but found %d calls", + mm_atomic.LoadUint64(&m.GetFilesByPathsMock.expectedInvocations), afterGetFilesByPathsCounter) + } +} + +type mMinioIMockUploadFile struct { + optional bool + mock *MinioIMock + defaultExpectation *MinioIMockUploadFileExpectation + expectations []*MinioIMockUploadFileExpectation + + callArgs []*MinioIMockUploadFileParams + mutex sync.RWMutex + + expectedInvocations uint64 +} + +// MinioIMockUploadFileExpectation specifies expectation struct of the MinioI.UploadFile +type MinioIMockUploadFileExpectation struct { + mock *MinioIMock + params *MinioIMockUploadFileParams + paramPtrs *MinioIMockUploadFileParamPtrs + results *MinioIMockUploadFileResults + Counter uint64 +} + +// MinioIMockUploadFileParams contains parameters of the MinioI.UploadFile +type MinioIMockUploadFileParams struct { + ctx context.Context + filePath string + fileContent any + fileMimeType string +} + +// MinioIMockUploadFileParamPtrs contains pointers to parameters of the MinioI.UploadFile +type MinioIMockUploadFileParamPtrs struct { + ctx *context.Context + filePath *string + fileContent *any + fileMimeType *string +} + +// MinioIMockUploadFileResults contains results of the MinioI.UploadFile +type MinioIMockUploadFileResults struct { + url string + objectInfo *miniogo.ObjectInfo + err error +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmUploadFile *mMinioIMockUploadFile) Optional() *mMinioIMockUploadFile { + mmUploadFile.optional = true + return mmUploadFile +} + +// Expect sets up expected params for MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) Expect(ctx context.Context, filePath string, fileContent any, fileMimeType string) *mMinioIMockUploadFile { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{} + } + + if mmUploadFile.defaultExpectation.paramPtrs != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by ExpectParams functions") + } + + mmUploadFile.defaultExpectation.params = &MinioIMockUploadFileParams{ctx, filePath, fileContent, fileMimeType} + for _, e := range mmUploadFile.expectations { + if minimock.Equal(e.params, mmUploadFile.defaultExpectation.params) { + mmUploadFile.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUploadFile.defaultExpectation.params) + } + } + + return mmUploadFile +} + +// ExpectCtxParam1 sets up expected param ctx for MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) ExpectCtxParam1(ctx context.Context) *mMinioIMockUploadFile { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{} + } + + if mmUploadFile.defaultExpectation.params != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Expect") + } + + if mmUploadFile.defaultExpectation.paramPtrs == nil { + mmUploadFile.defaultExpectation.paramPtrs = &MinioIMockUploadFileParamPtrs{} + } + mmUploadFile.defaultExpectation.paramPtrs.ctx = &ctx + + return mmUploadFile +} + +// ExpectFilePathParam2 sets up expected param filePath for MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) ExpectFilePathParam2(filePath string) *mMinioIMockUploadFile { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{} + } + + if mmUploadFile.defaultExpectation.params != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Expect") + } + + if mmUploadFile.defaultExpectation.paramPtrs == nil { + mmUploadFile.defaultExpectation.paramPtrs = &MinioIMockUploadFileParamPtrs{} + } + mmUploadFile.defaultExpectation.paramPtrs.filePath = &filePath + + return mmUploadFile +} + +// ExpectFileContentParam3 sets up expected param fileContent for MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) ExpectFileContentParam3(fileContent any) *mMinioIMockUploadFile { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{} + } + + if mmUploadFile.defaultExpectation.params != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Expect") + } + + if mmUploadFile.defaultExpectation.paramPtrs == nil { + mmUploadFile.defaultExpectation.paramPtrs = &MinioIMockUploadFileParamPtrs{} + } + mmUploadFile.defaultExpectation.paramPtrs.fileContent = &fileContent + + return mmUploadFile +} + +// ExpectFileMimeTypeParam4 sets up expected param fileMimeType for MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) ExpectFileMimeTypeParam4(fileMimeType string) *mMinioIMockUploadFile { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{} + } + + if mmUploadFile.defaultExpectation.params != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Expect") + } + + if mmUploadFile.defaultExpectation.paramPtrs == nil { + mmUploadFile.defaultExpectation.paramPtrs = &MinioIMockUploadFileParamPtrs{} + } + mmUploadFile.defaultExpectation.paramPtrs.fileMimeType = &fileMimeType + + return mmUploadFile +} + +// Inspect accepts an inspector function that has same arguments as the MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) Inspect(f func(ctx context.Context, filePath string, fileContent any, fileMimeType string)) *mMinioIMockUploadFile { + if mmUploadFile.mock.inspectFuncUploadFile != nil { + mmUploadFile.mock.t.Fatalf("Inspect function is already set for MinioIMock.UploadFile") + } + + mmUploadFile.mock.inspectFuncUploadFile = f + + return mmUploadFile +} + +// Return sets up results that will be returned by MinioI.UploadFile +func (mmUploadFile *mMinioIMockUploadFile) Return(url string, objectInfo *miniogo.ObjectInfo, err error) *MinioIMock { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + if mmUploadFile.defaultExpectation == nil { + mmUploadFile.defaultExpectation = &MinioIMockUploadFileExpectation{mock: mmUploadFile.mock} + } + mmUploadFile.defaultExpectation.results = &MinioIMockUploadFileResults{url, objectInfo, err} + return mmUploadFile.mock +} + +// Set uses given function f to mock the MinioI.UploadFile method +func (mmUploadFile *mMinioIMockUploadFile) Set(f func(ctx context.Context, filePath string, fileContent any, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error)) *MinioIMock { + if mmUploadFile.defaultExpectation != nil { + mmUploadFile.mock.t.Fatalf("Default expectation is already set for the MinioI.UploadFile method") + } + + if len(mmUploadFile.expectations) > 0 { + mmUploadFile.mock.t.Fatalf("Some expectations are already set for the MinioI.UploadFile method") + } + + mmUploadFile.mock.funcUploadFile = f + return mmUploadFile.mock +} + +// When sets expectation for the MinioI.UploadFile which will trigger the result defined by the following +// Then helper +func (mmUploadFile *mMinioIMockUploadFile) When(ctx context.Context, filePath string, fileContent any, fileMimeType string) *MinioIMockUploadFileExpectation { + if mmUploadFile.mock.funcUploadFile != nil { + mmUploadFile.mock.t.Fatalf("MinioIMock.UploadFile mock is already set by Set") + } + + expectation := &MinioIMockUploadFileExpectation{ + mock: mmUploadFile.mock, + params: &MinioIMockUploadFileParams{ctx, filePath, fileContent, fileMimeType}, + } + mmUploadFile.expectations = append(mmUploadFile.expectations, expectation) + return expectation +} + +// Then sets up MinioI.UploadFile return parameters for the expectation previously defined by the When method +func (e *MinioIMockUploadFileExpectation) Then(url string, objectInfo *miniogo.ObjectInfo, err error) *MinioIMock { + e.results = &MinioIMockUploadFileResults{url, objectInfo, err} + return e.mock +} + +// Times sets number of times MinioI.UploadFile should be invoked +func (mmUploadFile *mMinioIMockUploadFile) Times(n uint64) *mMinioIMockUploadFile { + if n == 0 { + mmUploadFile.mock.t.Fatalf("Times of MinioIMock.UploadFile mock can not be zero") + } + mm_atomic.StoreUint64(&mmUploadFile.expectedInvocations, n) + return mmUploadFile +} + +func (mmUploadFile *mMinioIMockUploadFile) invocationsDone() bool { + if len(mmUploadFile.expectations) == 0 && mmUploadFile.defaultExpectation == nil && mmUploadFile.mock.funcUploadFile == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmUploadFile.mock.afterUploadFileCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUploadFile.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// UploadFile implements minio.MinioI +func (mmUploadFile *MinioIMock) UploadFile(ctx context.Context, filePath string, fileContent any, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) { + mm_atomic.AddUint64(&mmUploadFile.beforeUploadFileCounter, 1) + defer mm_atomic.AddUint64(&mmUploadFile.afterUploadFileCounter, 1) + + if mmUploadFile.inspectFuncUploadFile != nil { + mmUploadFile.inspectFuncUploadFile(ctx, filePath, fileContent, fileMimeType) + } + + mm_params := MinioIMockUploadFileParams{ctx, filePath, fileContent, fileMimeType} + + // Record call args + mmUploadFile.UploadFileMock.mutex.Lock() + mmUploadFile.UploadFileMock.callArgs = append(mmUploadFile.UploadFileMock.callArgs, &mm_params) + mmUploadFile.UploadFileMock.mutex.Unlock() + + for _, e := range mmUploadFile.UploadFileMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.url, e.results.objectInfo, e.results.err + } + } + + if mmUploadFile.UploadFileMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUploadFile.UploadFileMock.defaultExpectation.Counter, 1) + mm_want := mmUploadFile.UploadFileMock.defaultExpectation.params + mm_want_ptrs := mmUploadFile.UploadFileMock.defaultExpectation.paramPtrs + + mm_got := MinioIMockUploadFileParams{ctx, filePath, fileContent, fileMimeType} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmUploadFile.t.Errorf("MinioIMock.UploadFile got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.filePath != nil && !minimock.Equal(*mm_want_ptrs.filePath, mm_got.filePath) { + mmUploadFile.t.Errorf("MinioIMock.UploadFile got unexpected parameter filePath, want: %#v, got: %#v%s\n", *mm_want_ptrs.filePath, mm_got.filePath, minimock.Diff(*mm_want_ptrs.filePath, mm_got.filePath)) + } + + if mm_want_ptrs.fileContent != nil && !minimock.Equal(*mm_want_ptrs.fileContent, mm_got.fileContent) { + mmUploadFile.t.Errorf("MinioIMock.UploadFile got unexpected parameter fileContent, want: %#v, got: %#v%s\n", *mm_want_ptrs.fileContent, mm_got.fileContent, minimock.Diff(*mm_want_ptrs.fileContent, mm_got.fileContent)) + } + + if mm_want_ptrs.fileMimeType != nil && !minimock.Equal(*mm_want_ptrs.fileMimeType, mm_got.fileMimeType) { + mmUploadFile.t.Errorf("MinioIMock.UploadFile got unexpected parameter fileMimeType, want: %#v, got: %#v%s\n", *mm_want_ptrs.fileMimeType, mm_got.fileMimeType, minimock.Diff(*mm_want_ptrs.fileMimeType, mm_got.fileMimeType)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmUploadFile.t.Errorf("MinioIMock.UploadFile got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmUploadFile.UploadFileMock.defaultExpectation.results + if mm_results == nil { + mmUploadFile.t.Fatal("No results are set for the MinioIMock.UploadFile") + } + return (*mm_results).url, (*mm_results).objectInfo, (*mm_results).err + } + if mmUploadFile.funcUploadFile != nil { + return mmUploadFile.funcUploadFile(ctx, filePath, fileContent, fileMimeType) + } + mmUploadFile.t.Fatalf("Unexpected call to MinioIMock.UploadFile. %v %v %v %v", ctx, filePath, fileContent, fileMimeType) + return +} + +// UploadFileAfterCounter returns a count of finished MinioIMock.UploadFile invocations +func (mmUploadFile *MinioIMock) UploadFileAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUploadFile.afterUploadFileCounter) +} + +// UploadFileBeforeCounter returns a count of MinioIMock.UploadFile invocations +func (mmUploadFile *MinioIMock) UploadFileBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUploadFile.beforeUploadFileCounter) +} + +// Calls returns a list of arguments used in each call to MinioIMock.UploadFile. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmUploadFile *mMinioIMockUploadFile) Calls() []*MinioIMockUploadFileParams { + mmUploadFile.mutex.RLock() + + argCopy := make([]*MinioIMockUploadFileParams, len(mmUploadFile.callArgs)) + copy(argCopy, mmUploadFile.callArgs) + + mmUploadFile.mutex.RUnlock() + + return argCopy +} + +// MinimockUploadFileDone returns true if the count of the UploadFile invocations corresponds +// the number of defined expectations +func (m *MinioIMock) MinimockUploadFileDone() bool { + if m.UploadFileMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.UploadFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.UploadFileMock.invocationsDone() +} + +// MinimockUploadFileInspect logs each unmet expectation +func (m *MinioIMock) MinimockUploadFileInspect() { + for _, e := range m.UploadFileMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to MinioIMock.UploadFile with params: %#v", *e.params) + } + } + + afterUploadFileCounter := mm_atomic.LoadUint64(&m.afterUploadFileCounter) + // if default expectation was set then invocations count should be greater than zero + if m.UploadFileMock.defaultExpectation != nil && afterUploadFileCounter < 1 { + if m.UploadFileMock.defaultExpectation.params == nil { + m.t.Error("Expected call to MinioIMock.UploadFile") + } else { + m.t.Errorf("Expected call to MinioIMock.UploadFile with params: %#v", *m.UploadFileMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcUploadFile != nil && afterUploadFileCounter < 1 { + m.t.Error("Expected call to MinioIMock.UploadFile") + } + + if !m.UploadFileMock.invocationsDone() && afterUploadFileCounter > 0 { + m.t.Errorf("Expected %d calls to MinioIMock.UploadFile but found %d calls", + mm_atomic.LoadUint64(&m.UploadFileMock.expectedInvocations), afterUploadFileCounter) + } +} + +type mMinioIMockUploadFileBytes struct { + optional bool + mock *MinioIMock + defaultExpectation *MinioIMockUploadFileBytesExpectation + expectations []*MinioIMockUploadFileBytesExpectation + + callArgs []*MinioIMockUploadFileBytesParams + mutex sync.RWMutex + + expectedInvocations uint64 +} + +// MinioIMockUploadFileBytesExpectation specifies expectation struct of the MinioI.UploadFileBytes +type MinioIMockUploadFileBytesExpectation struct { + mock *MinioIMock + params *MinioIMockUploadFileBytesParams + paramPtrs *MinioIMockUploadFileBytesParamPtrs + results *MinioIMockUploadFileBytesResults + Counter uint64 +} + +// MinioIMockUploadFileBytesParams contains parameters of the MinioI.UploadFileBytes +type MinioIMockUploadFileBytesParams struct { + ctx context.Context + logger *zap.Logger + filePath string + fileBytes []byte + fileMimeType string +} + +// MinioIMockUploadFileBytesParamPtrs contains pointers to parameters of the MinioI.UploadFileBytes +type MinioIMockUploadFileBytesParamPtrs struct { + ctx *context.Context + logger **zap.Logger + filePath *string + fileBytes *[]byte + fileMimeType *string +} + +// MinioIMockUploadFileBytesResults contains results of the MinioI.UploadFileBytes +type MinioIMockUploadFileBytesResults struct { + url string + objectInfo *miniogo.ObjectInfo + err error +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Optional() *mMinioIMockUploadFileBytes { + mmUploadFileBytes.optional = true + return mmUploadFileBytes +} + +// Expect sets up expected params for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Expect(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by ExpectParams functions") + } + + mmUploadFileBytes.defaultExpectation.params = &MinioIMockUploadFileBytesParams{ctx, logger, filePath, fileBytes, fileMimeType} + for _, e := range mmUploadFileBytes.expectations { + if minimock.Equal(e.params, mmUploadFileBytes.defaultExpectation.params) { + mmUploadFileBytes.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUploadFileBytes.defaultExpectation.params) + } + } + + return mmUploadFileBytes +} + +// ExpectCtxParam1 sets up expected param ctx for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) ExpectCtxParam1(ctx context.Context) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.params != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Expect") + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs == nil { + mmUploadFileBytes.defaultExpectation.paramPtrs = &MinioIMockUploadFileBytesParamPtrs{} + } + mmUploadFileBytes.defaultExpectation.paramPtrs.ctx = &ctx + + return mmUploadFileBytes +} + +// ExpectLoggerParam2 sets up expected param logger for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) ExpectLoggerParam2(logger *zap.Logger) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.params != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Expect") + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs == nil { + mmUploadFileBytes.defaultExpectation.paramPtrs = &MinioIMockUploadFileBytesParamPtrs{} + } + mmUploadFileBytes.defaultExpectation.paramPtrs.logger = &logger + + return mmUploadFileBytes +} + +// ExpectFilePathParam3 sets up expected param filePath for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) ExpectFilePathParam3(filePath string) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.params != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Expect") + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs == nil { + mmUploadFileBytes.defaultExpectation.paramPtrs = &MinioIMockUploadFileBytesParamPtrs{} + } + mmUploadFileBytes.defaultExpectation.paramPtrs.filePath = &filePath + + return mmUploadFileBytes +} + +// ExpectFileBytesParam4 sets up expected param fileBytes for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) ExpectFileBytesParam4(fileBytes []byte) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.params != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Expect") + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs == nil { + mmUploadFileBytes.defaultExpectation.paramPtrs = &MinioIMockUploadFileBytesParamPtrs{} + } + mmUploadFileBytes.defaultExpectation.paramPtrs.fileBytes = &fileBytes + + return mmUploadFileBytes +} + +// ExpectFileMimeTypeParam5 sets up expected param fileMimeType for MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) ExpectFileMimeTypeParam5(fileMimeType string) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{} + } + + if mmUploadFileBytes.defaultExpectation.params != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Expect") + } + + if mmUploadFileBytes.defaultExpectation.paramPtrs == nil { + mmUploadFileBytes.defaultExpectation.paramPtrs = &MinioIMockUploadFileBytesParamPtrs{} + } + mmUploadFileBytes.defaultExpectation.paramPtrs.fileMimeType = &fileMimeType + + return mmUploadFileBytes +} + +// Inspect accepts an inspector function that has same arguments as the MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Inspect(f func(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string)) *mMinioIMockUploadFileBytes { + if mmUploadFileBytes.mock.inspectFuncUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("Inspect function is already set for MinioIMock.UploadFileBytes") + } + + mmUploadFileBytes.mock.inspectFuncUploadFileBytes = f + + return mmUploadFileBytes +} + +// Return sets up results that will be returned by MinioI.UploadFileBytes +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Return(url string, objectInfo *miniogo.ObjectInfo, err error) *MinioIMock { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + if mmUploadFileBytes.defaultExpectation == nil { + mmUploadFileBytes.defaultExpectation = &MinioIMockUploadFileBytesExpectation{mock: mmUploadFileBytes.mock} + } + mmUploadFileBytes.defaultExpectation.results = &MinioIMockUploadFileBytesResults{url, objectInfo, err} + return mmUploadFileBytes.mock +} + +// Set uses given function f to mock the MinioI.UploadFileBytes method +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Set(f func(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error)) *MinioIMock { + if mmUploadFileBytes.defaultExpectation != nil { + mmUploadFileBytes.mock.t.Fatalf("Default expectation is already set for the MinioI.UploadFileBytes method") + } + + if len(mmUploadFileBytes.expectations) > 0 { + mmUploadFileBytes.mock.t.Fatalf("Some expectations are already set for the MinioI.UploadFileBytes method") + } + + mmUploadFileBytes.mock.funcUploadFileBytes = f + return mmUploadFileBytes.mock +} + +// When sets expectation for the MinioI.UploadFileBytes which will trigger the result defined by the following +// Then helper +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) When(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) *MinioIMockUploadFileBytesExpectation { + if mmUploadFileBytes.mock.funcUploadFileBytes != nil { + mmUploadFileBytes.mock.t.Fatalf("MinioIMock.UploadFileBytes mock is already set by Set") + } + + expectation := &MinioIMockUploadFileBytesExpectation{ + mock: mmUploadFileBytes.mock, + params: &MinioIMockUploadFileBytesParams{ctx, logger, filePath, fileBytes, fileMimeType}, + } + mmUploadFileBytes.expectations = append(mmUploadFileBytes.expectations, expectation) + return expectation +} + +// Then sets up MinioI.UploadFileBytes return parameters for the expectation previously defined by the When method +func (e *MinioIMockUploadFileBytesExpectation) Then(url string, objectInfo *miniogo.ObjectInfo, err error) *MinioIMock { + e.results = &MinioIMockUploadFileBytesResults{url, objectInfo, err} + return e.mock +} + +// Times sets number of times MinioI.UploadFileBytes should be invoked +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Times(n uint64) *mMinioIMockUploadFileBytes { + if n == 0 { + mmUploadFileBytes.mock.t.Fatalf("Times of MinioIMock.UploadFileBytes mock can not be zero") + } + mm_atomic.StoreUint64(&mmUploadFileBytes.expectedInvocations, n) + return mmUploadFileBytes +} + +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) invocationsDone() bool { + if len(mmUploadFileBytes.expectations) == 0 && mmUploadFileBytes.defaultExpectation == nil && mmUploadFileBytes.mock.funcUploadFileBytes == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmUploadFileBytes.mock.afterUploadFileBytesCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmUploadFileBytes.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// UploadFileBytes implements minio.MinioI +func (mmUploadFileBytes *MinioIMock) UploadFileBytes(ctx context.Context, logger *zap.Logger, filePath string, fileBytes []byte, fileMimeType string) (url string, objectInfo *miniogo.ObjectInfo, err error) { + mm_atomic.AddUint64(&mmUploadFileBytes.beforeUploadFileBytesCounter, 1) + defer mm_atomic.AddUint64(&mmUploadFileBytes.afterUploadFileBytesCounter, 1) + + if mmUploadFileBytes.inspectFuncUploadFileBytes != nil { + mmUploadFileBytes.inspectFuncUploadFileBytes(ctx, logger, filePath, fileBytes, fileMimeType) + } + + mm_params := MinioIMockUploadFileBytesParams{ctx, logger, filePath, fileBytes, fileMimeType} + + // Record call args + mmUploadFileBytes.UploadFileBytesMock.mutex.Lock() + mmUploadFileBytes.UploadFileBytesMock.callArgs = append(mmUploadFileBytes.UploadFileBytesMock.callArgs, &mm_params) + mmUploadFileBytes.UploadFileBytesMock.mutex.Unlock() + + for _, e := range mmUploadFileBytes.UploadFileBytesMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.url, e.results.objectInfo, e.results.err + } + } + + if mmUploadFileBytes.UploadFileBytesMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmUploadFileBytes.UploadFileBytesMock.defaultExpectation.Counter, 1) + mm_want := mmUploadFileBytes.UploadFileBytesMock.defaultExpectation.params + mm_want_ptrs := mmUploadFileBytes.UploadFileBytesMock.defaultExpectation.paramPtrs + + mm_got := MinioIMockUploadFileBytesParams{ctx, logger, filePath, fileBytes, fileMimeType} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.logger != nil && !minimock.Equal(*mm_want_ptrs.logger, mm_got.logger) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameter logger, want: %#v, got: %#v%s\n", *mm_want_ptrs.logger, mm_got.logger, minimock.Diff(*mm_want_ptrs.logger, mm_got.logger)) + } + + if mm_want_ptrs.filePath != nil && !minimock.Equal(*mm_want_ptrs.filePath, mm_got.filePath) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameter filePath, want: %#v, got: %#v%s\n", *mm_want_ptrs.filePath, mm_got.filePath, minimock.Diff(*mm_want_ptrs.filePath, mm_got.filePath)) + } + + if mm_want_ptrs.fileBytes != nil && !minimock.Equal(*mm_want_ptrs.fileBytes, mm_got.fileBytes) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameter fileBytes, want: %#v, got: %#v%s\n", *mm_want_ptrs.fileBytes, mm_got.fileBytes, minimock.Diff(*mm_want_ptrs.fileBytes, mm_got.fileBytes)) + } + + if mm_want_ptrs.fileMimeType != nil && !minimock.Equal(*mm_want_ptrs.fileMimeType, mm_got.fileMimeType) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameter fileMimeType, want: %#v, got: %#v%s\n", *mm_want_ptrs.fileMimeType, mm_got.fileMimeType, minimock.Diff(*mm_want_ptrs.fileMimeType, mm_got.fileMimeType)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmUploadFileBytes.t.Errorf("MinioIMock.UploadFileBytes got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmUploadFileBytes.UploadFileBytesMock.defaultExpectation.results + if mm_results == nil { + mmUploadFileBytes.t.Fatal("No results are set for the MinioIMock.UploadFileBytes") + } + return (*mm_results).url, (*mm_results).objectInfo, (*mm_results).err + } + if mmUploadFileBytes.funcUploadFileBytes != nil { + return mmUploadFileBytes.funcUploadFileBytes(ctx, logger, filePath, fileBytes, fileMimeType) + } + mmUploadFileBytes.t.Fatalf("Unexpected call to MinioIMock.UploadFileBytes. %v %v %v %v %v", ctx, logger, filePath, fileBytes, fileMimeType) + return +} + +// UploadFileBytesAfterCounter returns a count of finished MinioIMock.UploadFileBytes invocations +func (mmUploadFileBytes *MinioIMock) UploadFileBytesAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmUploadFileBytes.afterUploadFileBytesCounter) +} + +// UploadFileBytesBeforeCounter returns a count of MinioIMock.UploadFileBytes invocations +func (mmUploadFileBytes *MinioIMock) UploadFileBytesBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmUploadFileBytes.beforeUploadFileBytesCounter) +} + +// Calls returns a list of arguments used in each call to MinioIMock.UploadFileBytes. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmUploadFileBytes *mMinioIMockUploadFileBytes) Calls() []*MinioIMockUploadFileBytesParams { + mmUploadFileBytes.mutex.RLock() + + argCopy := make([]*MinioIMockUploadFileBytesParams, len(mmUploadFileBytes.callArgs)) + copy(argCopy, mmUploadFileBytes.callArgs) + + mmUploadFileBytes.mutex.RUnlock() + + return argCopy +} + +// MinimockUploadFileBytesDone returns true if the count of the UploadFileBytes invocations corresponds +// the number of defined expectations +func (m *MinioIMock) MinimockUploadFileBytesDone() bool { + if m.UploadFileBytesMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.UploadFileBytesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.UploadFileBytesMock.invocationsDone() +} + +// MinimockUploadFileBytesInspect logs each unmet expectation +func (m *MinioIMock) MinimockUploadFileBytesInspect() { + for _, e := range m.UploadFileBytesMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to MinioIMock.UploadFileBytes with params: %#v", *e.params) + } + } + + afterUploadFileBytesCounter := mm_atomic.LoadUint64(&m.afterUploadFileBytesCounter) + // if default expectation was set then invocations count should be greater than zero + if m.UploadFileBytesMock.defaultExpectation != nil && afterUploadFileBytesCounter < 1 { + if m.UploadFileBytesMock.defaultExpectation.params == nil { + m.t.Error("Expected call to MinioIMock.UploadFileBytes") + } else { + m.t.Errorf("Expected call to MinioIMock.UploadFileBytes with params: %#v", *m.UploadFileBytesMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcUploadFileBytes != nil && afterUploadFileBytesCounter < 1 { + m.t.Error("Expected call to MinioIMock.UploadFileBytes") + } + + if !m.UploadFileBytesMock.invocationsDone() && afterUploadFileBytesCounter > 0 { + m.t.Errorf("Expected %d calls to MinioIMock.UploadFileBytes but found %d calls", + mm_atomic.LoadUint64(&m.UploadFileBytesMock.expectedInvocations), afterUploadFileBytesCounter) + } +} + +// MinimockFinish checks that all mocked methods have been called the expected number of times +func (m *MinioIMock) MinimockFinish() { + m.finishOnce.Do(func() { + if !m.minimockDone() { + m.MinimockDeleteFileInspect() + + m.MinimockGetFileInspect() + + m.MinimockGetFilesByPathsInspect() + + m.MinimockUploadFileInspect() + + m.MinimockUploadFileBytesInspect() + } + }) +} + +// MinimockWait waits for all mocked methods to be called the expected number of times +func (m *MinioIMock) MinimockWait(timeout mm_time.Duration) { + timeoutCh := mm_time.After(timeout) + for { + if m.minimockDone() { + return + } + select { + case <-timeoutCh: + m.MinimockFinish() + return + case <-mm_time.After(10 * mm_time.Millisecond): + } + } +} + +func (m *MinioIMock) minimockDone() bool { + done := true + return done && + m.MinimockDeleteFileDone() && + m.MinimockGetFileDone() && + m.MinimockGetFilesByPathsDone() && + m.MinimockUploadFileDone() && + m.MinimockUploadFileBytesDone() +} diff --git a/resource/resource.go b/resource/resource.go new file mode 100644 index 0000000..78445fb --- /dev/null +++ b/resource/resource.go @@ -0,0 +1,28 @@ +package resource + +import ( + "context" + "strings" + + "google.golang.org/grpc/metadata" + + "github.com/instill-ai/x/constant" +) + +// GetRequestSingleHeader get a request header, the header has to be single-value HTTP header +func GetRequestSingleHeader(ctx context.Context, header string) string { + metaHeader := metadata.ValueFromIncomingContext(ctx, strings.ToLower(header)) + if len(metaHeader) != 1 { + return "" + } + return metaHeader[0] +} + +func GetRequesterUIDAndUserUID(ctx context.Context) (string, string) { + requesterUID := GetRequestSingleHeader(ctx, constant.HeaderRequesterUIDKey) + userUID := GetRequestSingleHeader(ctx, constant.HeaderUserUIDKey) + if strings.TrimSpace(requesterUID) == "" { + requesterUID = userUID + } + return requesterUID, userUID +} diff --git a/resource/resource_test.go b/resource/resource_test.go new file mode 100644 index 0000000..9e6f5ff --- /dev/null +++ b/resource/resource_test.go @@ -0,0 +1,28 @@ +package resource_test + +import ( + "context" + "testing" + + "github.com/gofrs/uuid" + "google.golang.org/grpc/metadata" + + qt "github.com/frankban/quicktest" + + "github.com/instill-ai/x/constant" + "github.com/instill-ai/x/resource" +) + +func TestGetRequesterUIDAndUserUID(t *testing.T) { + requesterUID := uuid.Must(uuid.NewV4()).String() + userUID := uuid.Must(uuid.NewV4()).String() + m := make(map[string]string) + m[constant.HeaderRequesterUIDKey] = requesterUID + m[constant.HeaderUserUIDKey] = userUID + ctx := metadata.NewIncomingContext(context.Background(), metadata.New(m)) + + c := qt.New(t) + checkRequesterUID, checkUserUID := resource.GetRequesterUIDAndUserUID(ctx) + c.Check(checkRequesterUID, qt.Equals, requesterUID) + c.Check(checkUserUID, qt.Equals, userUID) +} diff --git a/structutil/structutil.go b/structutil/structutil.go index 4170736..ea672b4 100644 --- a/structutil/structutil.go +++ b/structutil/structutil.go @@ -22,17 +22,9 @@ func BytesToInterface(bytes []byte) (interface{}, error) { return obj, nil } +// Deprecated: use structpb.NewStruct() directly func MapToProtobufStruct(m map[string]interface{}) (*structpb.Struct, error) { - b, err := json.Marshal(m) - if err != nil { - return nil, err - } - s := &structpb.Struct{} - err = protojson.Unmarshal(b, s) - if err != nil { - return nil, err - } - return s, nil + return structpb.NewStruct(m) } func ProtobufStructToMap(s *structpb.Struct) (map[string]interface{}, error) { @@ -49,7 +41,7 @@ func ProtobufStructToMap(s *structpb.Struct) (map[string]interface{}, error) { } func StructToProtobufStruct(s interface{}) (*structpb.Struct, error) { - return MapToProtobufStruct(s.(map[string]interface{})) + return structpb.NewStruct(s.(map[string]interface{})) } func ProtobufStructToStruct(s *structpb.Struct) (interface{}, error) {