diff --git a/.env.template b/.env.template index 3def5ec..c91303a 100644 --- a/.env.template +++ b/.env.template @@ -1,8 +1,9 @@ APP_PORT=3005 APP_ENV=development -APP_MAX_FILE_SIZE_MB=1024 +APP_MAX_FILE_SIZE_MB= -DB_URL=postgres://root:1234@localhost:5432/rpkm67_db - -STORE_BUCKET_NAME=rpkm67-bucket -STORE_REGION=us-east-1 \ No newline at end of file +ENDPOINT= +ACCESS_KEY= +SECRET_KEY= +USE_SSL= +BUCKET_NAME= \ No newline at end of file diff --git a/Makefile b/Makefile index 4e70aa5..028056e 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,13 @@ server: watch: air + mock-gen: + mockgen -source ./internal/object/object.repository.go -destination ./mocks/object/object.repository.go + mockgen -source ./internal/object/object.service.go -destination ./mocks/object/object.service.go + mockgen -source ./internal/client/http/http.client.go -destination ./mocks/client/http/http.client.go + mockgen -source ./internal/client/store/store.client.go -destination ./mocks/client/store/store.client.go + mockgen -source ./internal/utils/random.utils.go -destination ./mocks/utils/random/random.utils.go test: go vet ./... diff --git a/cmd/main.go b/cmd/main.go index 771ae0e..b4dbbeb 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -13,9 +13,9 @@ import ( objectProto "github.com/isd-sgcu/rpkm67-go-proto/rpkm67/store/object/v1" "github.com/isd-sgcu/rpkm67-store/config" - "github.com/isd-sgcu/rpkm67-store/database" "github.com/isd-sgcu/rpkm67-store/internal/client/store" "github.com/isd-sgcu/rpkm67-store/internal/object" + "github.com/isd-sgcu/rpkm67-store/internal/utils" "github.com/isd-sgcu/rpkm67-store/logger" "github.com/minio/minio-go/v7" "github.com/minio/minio-go/v7/pkg/credentials" @@ -31,9 +31,12 @@ func main() { if err != nil { panic(fmt.Sprintf("Failed to load config: %v", err)) } + fmt.Println("conf: ", conf) + + logger := logger.New(conf) minioClient, err := minio.New(conf.Store.Endpoint, &minio.Options{ - Creds: credentials.NewStaticV4(conf.Store.AccessKey, conf.Store.SecretKey, conf.Store.Token), + Creds: credentials.NewStaticV4(conf.Store.AccessKey, conf.Store.SecretKey, ""), Secure: conf.Store.UseSSL, }) if err != nil { @@ -43,15 +46,10 @@ func main() { storeClient := store.NewClient(minioClient) httpClient := &http.Client{} - logger := logger.New(conf) + randomUtils := utils.NewRandomUtils() - db, err := database.InitDatabase(&conf.DB, conf.App.IsDevelopment()) - if err != nil { - panic(fmt.Sprintf("Failed to connect to database: %v", err)) - } - - objectRepo := object.NewRepository(db) - objectSvc := object.NewService(objectRepo, *conf, storeClient, *httpClient, logger) + objectRepo := object.NewRepository(&conf.Store, storeClient, httpClient) + objectSvc := object.NewService(objectRepo, &conf.Store, logger.Named("objectSvc"), randomUtils) listener, err := net.Listen("tcp", fmt.Sprintf(":%v", conf.App.Port)) if err != nil { @@ -65,10 +63,10 @@ func main() { reflection.Register(grpcServer) go func() { - logger.Sugar().Infof("RPKM67 Auth starting at port %v", conf.App.Port) + logger.Sugar().Infof("RPKM67 Store starting at port %v", conf.App.Port) if err := grpcServer.Serve(listener); err != nil { - logger.Fatal("Failed to start RPKM67 Auth service", zap.Error(err)) + logger.Fatal("Failed to start RPKM67 Store service", zap.Error(err)) } }() @@ -77,13 +75,6 @@ func main() { grpcServer.GracefulStop() return nil }, - "database": func(ctx context.Context) error { - sqlDB, err := db.DB() - if err != nil { - return nil - } - return sqlDB.Close() - }, }) <-wait diff --git a/config/config.go b/config/config.go index 40d3261..2975c9a 100644 --- a/config/config.go +++ b/config/config.go @@ -18,19 +18,18 @@ type DB struct { } type Store struct { - Endpoint string `mapstructure:"endpoint"` - AccessKey string `mapstructure:"access_key"` - SecretKey string `mapstructure:"secret_key"` - UseSSL bool `mapstructure:"use_ssl"` - BucketName string `mapstructure:"bucket_name"` - Region string `mapstructure:"region"` - Token string `mapstructure:"token"` + Endpoint string + AccessKey string + SecretKey string + UseSSL bool + BucketName string + Region string + Token string } type Config struct { App App `mapstructure:"app"` Store Store `mapstructure:"store"` - DB DB `mapstructure:"db"` } func LoadConfig() (config *Config, err error) { @@ -52,23 +51,16 @@ func LoadConfig() (config *Config, err error) { } storeConfig := Store{ - BucketName: os.Getenv("STORE_BUCKET_NAME"), - Region: os.Getenv("STORE_REGION"), - Endpoint: os.Getenv("STORE_ENDPOINT"), - AccessKey: os.Getenv("STORE_ACCESS_KEY"), - SecretKey: os.Getenv("STORE_SECRET_KEY"), - UseSSL: os.Getenv("STORE_USE_SSL") == "true", - Token: os.Getenv("STORE_TOKEN"), - } - - dbConfig := DB{ - Url: os.Getenv("DB_URL"), + BucketName: os.Getenv("BUCKET_NAME"), + Endpoint: os.Getenv("ENDPOINT"), + AccessKey: os.Getenv("ACCESS_KEY"), + SecretKey: os.Getenv("SECRET_KEY"), + UseSSL: os.Getenv("USE_SSL") == "true", } return &Config{ App: appConfig, Store: storeConfig, - DB: dbConfig, }, nil } diff --git a/database/db.connection.go b/database/db.connection.go deleted file mode 100644 index 4f92d9c..0000000 --- a/database/db.connection.go +++ /dev/null @@ -1,29 +0,0 @@ -package database - -import ( - "github.com/isd-sgcu/rpkm67-store/config" - "github.com/isd-sgcu/rpkm67-store/internal/model" - "gorm.io/driver/postgres" - "gorm.io/gorm" - gormLogger "gorm.io/gorm/logger" -) - -func InitDatabase(conf *config.DB, isDebug bool) (db *gorm.DB, err error) { - gormConf := &gorm.Config{TranslateError: true} - - if !isDebug { - gormConf.Logger = gormLogger.Default.LogMode(gormLogger.Silent) - } - - db, err = gorm.Open(postgres.Open(conf.Url), gormConf) - if err != nil { - return nil, err - } - - err = db.AutoMigrate(&model.Object{}) - if err != nil { - return nil, err - } - - return -} diff --git a/docker-compose.yaml b/docker-compose.yaml deleted file mode 100644 index 3f27365..0000000 --- a/docker-compose.yaml +++ /dev/null @@ -1,21 +0,0 @@ -version: "3.9" - -services: - db: - image: postgres:15.1-alpine3.17 - container_name: db - restart: unless-stopped - environment: - POSTGRES_USER: root - POSTGRES_PASSWORD: "1234" - POSTGRES_DB: rpkm67_db - networks: - - rpkm67 - volumes: - - ./volumes/postgres:/var/lib/postgresql/data - ports: - - "5432:5432" - -networks: - rpkm67: - name: rpkm67 \ No newline at end of file diff --git a/go.mod b/go.mod index 30d29fe..53b7a19 100644 --- a/go.mod +++ b/go.mod @@ -4,38 +4,35 @@ go 1.21.5 require ( github.com/joho/godotenv v1.5.1 + github.com/stretchr/testify v1.9.0 go.uber.org/zap v1.27.0 ) require ( + github.com/davecgh/go-spew v1.1.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/goccy/go-json v0.10.2 // indirect - github.com/jackc/pgpassfile v1.0.0 // indirect - github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect - github.com/jackc/pgx/v5 v5.5.5 // indirect - github.com/jackc/puddle/v2 v2.2.1 // indirect - github.com/jinzhu/inflection v1.0.0 // indirect - github.com/jinzhu/now v1.1.5 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/klauspost/compress v1.17.6 // indirect - github.com/klauspost/cpuid/v2 v2.2.6 // indirect + github.com/klauspost/cpuid/v2 v2.2.7 // indirect github.com/minio/md5-simd v1.1.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect github.com/rs/xid v1.5.0 // indirect - golang.org/x/crypto v0.21.0 // indirect - golang.org/x/net v0.23.0 // indirect - golang.org/x/sync v0.6.0 // indirect - golang.org/x/sys v0.18.0 // indirect - golang.org/x/text v0.14.0 // indirect + golang.org/x/crypto v0.23.0 // indirect + golang.org/x/net v0.25.0 // indirect + golang.org/x/sys v0.20.0 // indirect + golang.org/x/text v0.15.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 // indirect google.golang.org/protobuf v1.34.2 // indirect gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) require ( - github.com/google/uuid v1.6.0 - github.com/isd-sgcu/rpkm67-go-proto v0.1.4 + github.com/golang/mock v1.6.0 + github.com/isd-sgcu/rpkm67-go-proto v0.1.5 github.com/minio/minio-go/v7 v7.0.72 + github.com/pkg/errors v0.9.1 go.uber.org/multierr v1.10.0 // indirect google.golang.org/grpc v1.64.0 - gorm.io/driver/postgres v1.5.9 - gorm.io/gorm v1.25.10 ) diff --git a/go.sum b/go.sum index 48c12f6..b889de0 100644 --- a/go.sum +++ b/go.sum @@ -1,80 +1,83 @@ -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/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= 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/isd-sgcu/rpkm67-go-proto v0.1.3 h1:9+wrvKUUY5GDot1SmU9HtUgf8JzhPLHWKtCfmBQU+Yw= -github.com/isd-sgcu/rpkm67-go-proto v0.1.3/go.mod h1:Z5SYz5kEe4W+MdqPouF0zEOiaqvg+s9I1S5d0q6e+Jw= -github.com/isd-sgcu/rpkm67-go-proto v0.1.4 h1:2nZRoBrHZUMN6QogR46yzqi7RoydmqRyF496udEknGg= -github.com/isd-sgcu/rpkm67-go-proto v0.1.4/go.mod h1:Z5SYz5kEe4W+MdqPouF0zEOiaqvg+s9I1S5d0q6e+Jw= -github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= -github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= -github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= -github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw= -github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= -github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= -github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/isd-sgcu/rpkm67-go-proto v0.1.5 h1:WShrm8DeVqIY1ZelgM88vW8LMnLxF6dTt650A0YkC8U= +github.com/isd-sgcu/rpkm67-go-proto v0.1.5/go.mod h1:Z5SYz5kEe4W+MdqPouF0zEOiaqvg+s9I1S5d0q6e+Jw= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI= github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc= -github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= +github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= 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.72 h1:ZSbxs2BfJensLyHdVOgHv+pfmvxYraaUy07ER04dWnA= github.com/minio/minio-go/v7 v7.0.72/go.mod h1:4yBA8v80xGA30cfM3fz0DKYMXunWl/AV/6tWEs9ryzo= +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/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +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.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ= go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= -golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +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.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac= +golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/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/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.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.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc= google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY= google.golang.org/grpc v1.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY= google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg= google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/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= -gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8= -gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= -gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s= -gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= diff --git a/internal/client/store/store.client.go b/internal/client/store/store.client.go index f951634..cd0dd94 100644 --- a/internal/client/store/store.client.go +++ b/internal/client/store/store.client.go @@ -3,36 +3,27 @@ package store import ( "context" "io" - "time" "github.com/minio/minio-go/v7" ) type Client interface { - Upload(bucketName, name string, reader io.Reader, objectSize int64, opts minio.PutObjectOptions) (info minio.UploadInfo, err error) - DeleteByKey(bucketName, key string, opts minio.RemoveObjectOptions) error + PutObject(ctx context.Context, bucketName string, objectName string, reader io.Reader, objectSize int64, opts minio.PutObjectOptions) (info minio.UploadInfo, err error) + RemoveObject(ctx context.Context, bucketName string, objectName string, opts minio.RemoveObjectOptions) error } type clientImpl struct { *minio.Client } -func (c *clientImpl) DeleteByKey(bucketName string, key string, opts minio.RemoveObjectOptions) error { - ctx := context.Background() - ctx, cancel := context.WithTimeout(ctx, 50*time.Second) - defer cancel() - - return c.Client.RemoveObject(ctx, bucketName, key, opts) +func NewClient(minioClient *minio.Client) Client { + return &clientImpl{minioClient} } -func (c *clientImpl) Upload(bucketName string, name string, reader io.Reader, objectSize int64, opts minio.PutObjectOptions) (info minio.UploadInfo, err error) { - ctx := context.Background() - ctx, cancel := context.WithTimeout(ctx, 50*time.Second) - defer cancel() - - return c.Client.PutObject(ctx, bucketName, name, reader, objectSize, opts) +func (c *clientImpl) PutObject(ctx context.Context, bucketName string, objectName string, reader io.Reader, objectSize int64, opts minio.PutObjectOptions) (info minio.UploadInfo, err error) { + return c.Client.PutObject(ctx, bucketName, objectName, reader, objectSize, opts) } -func NewClient(minioClient *minio.Client) Client { - return &clientImpl{minioClient} +func (c *clientImpl) RemoveObject(ctx context.Context, bucketName string, objectName string, opts minio.RemoveObjectOptions) error { + return c.Client.RemoveObject(ctx, bucketName, objectName, opts) } diff --git a/internal/model/common.model.go b/internal/model/common.model.go deleted file mode 100644 index 6c15b42..0000000 --- a/internal/model/common.model.go +++ /dev/null @@ -1,21 +0,0 @@ -package model - -import ( - "time" - - "github.com/google/uuid" - "gorm.io/gorm" -) - -type Base struct { - ID uuid.UUID `json:"id" gorm:"primary_key"` - CreatedAt time.Time `json:"created_at" gorm:"type:timestamp;autoCreateTime:nano"` - UpdatedAt time.Time `json:"updated_at" gorm:"type:timestamp;autoUpdateTime:nano"` - DeletedAt gorm.DeletedAt `json:"deleted_at" gorm:"index;type:timestamp"` -} - -func (b *Base) BeforeCreate(_ *gorm.DB) error { - b.ID = uuid.New() - - return nil -} diff --git a/internal/model/object.model.go b/internal/model/object.model.go deleted file mode 100644 index 8066721..0000000 --- a/internal/model/object.model.go +++ /dev/null @@ -1,12 +0,0 @@ -package model - -import ( - "github.com/google/uuid" -) - -type Object struct { - Base - ID uuid.UUID `json:"id" gorm:"primary_key"` - ImageUrl string `json:"image_url" gorm:"mediumtext"` - ObjectKey string `json:"object_key" gorm:"mediumtext"` -} diff --git a/internal/object/object.repository.go b/internal/object/object.repository.go index 8ad7dce..0c3dc2d 100644 --- a/internal/object/object.repository.go +++ b/internal/object/object.repository.go @@ -1,32 +1,90 @@ package object import ( - "github.com/isd-sgcu/rpkm67-store/internal/model" - "gorm.io/gorm" + "bytes" + "context" + "fmt" + "net/http" + "time" + + "github.com/isd-sgcu/rpkm67-store/config" + httpClient "github.com/isd-sgcu/rpkm67-store/internal/client/http" + storeClient "github.com/isd-sgcu/rpkm67-store/internal/client/store" + "github.com/minio/minio-go/v7" + "github.com/pkg/errors" ) type Repository interface { - FindByKey(key string, result *model.Object) error - Upload(file *model.Object) error - DeleteByKey(key string) error + Upload(file []byte, bucketName string, objectKey string) (url string, key string, err error) + Delete(bucketName string, objectKey string) (err error) + Get(bucketName string, objectKey string) (url string, err error) + GetURL(bucketName string, objectKey string) string } type repositoryImpl struct { - db *gorm.DB + conf *config.Store + storeClient storeClient.Client + httpClient httpClient.Client } -func NewRepository(db *gorm.DB) Repository { - return &repositoryImpl{db: db} +func NewRepository(conf *config.Store, storeClient storeClient.Client, httpClient httpClient.Client) Repository { + return &repositoryImpl{ + conf: conf, + storeClient: storeClient, + httpClient: httpClient, + } } -func (r *repositoryImpl) DeleteByKey(key string) error { - return r.db.Where("object_key = ?", key).Delete(&model.Object{}).Error +func (r *repositoryImpl) Upload(file []byte, bucketName string, objectKey string) (url string, key string, err error) { + ctx := context.Background() + _, cancel := context.WithTimeout(ctx, 50*time.Second) + defer cancel() + + buffer := bytes.NewReader(file) + + uploadOutput, err := r.storeClient.PutObject(ctx, bucketName, objectKey, buffer, + buffer.Size(), minio.PutObjectOptions{}) + if err != nil { + return "", "", errors.Wrap(err, fmt.Sprintf("Couldn't upload object to %v/%v.", bucketName, objectKey)) + } + + return r.GetURL(bucketName, objectKey), uploadOutput.Key, nil } -func (r *repositoryImpl) FindByKey(key string, result *model.Object) error { - return r.db.Where("object_key = ?", key).First(result).Error +func (r *repositoryImpl) Delete(bucketName string, objectKey string) (err error) { + ctx := context.Background() + _, cancel := context.WithTimeout(ctx, 50*time.Second) + defer cancel() + + opts := minio.RemoveObjectOptions{ + GovernanceBypass: true, + } + err = r.storeClient.RemoveObject(ctx, bucketName, objectKey, opts) + if err != nil { + return errors.Wrap(err, fmt.Sprintf("Couldn't delete object %v/%v.", bucketName, objectKey)) + } + + return nil +} + +func (r *repositoryImpl) Get(bucketName string, objectKey string) (url string, err error) { + ctx := context.Background() + _, cancel := context.WithTimeout(ctx, 50*time.Second) + defer cancel() + + url = r.GetURL(bucketName, objectKey) + + resp, err := r.httpClient.Get(url) + if err != nil { + return "", errors.Wrap(err, fmt.Sprintf("Couldn't get object %v/%v.", bucketName, objectKey)) + } + if resp.StatusCode != http.StatusOK { + return "", nil + } + + return url, nil } -func (r *repositoryImpl) Upload(file *model.Object) error { - return r.db.Create(&file).Error +func (r *repositoryImpl) GetURL(bucketName string, objectKey string) string { + return "https://" + r.conf.Endpoint + "/" + bucketName + "/" + objectKey } diff --git a/internal/object/object.service.go b/internal/object/object.service.go index f8fc31b..4cd6146 100644 --- a/internal/object/object.service.go +++ b/internal/object/object.service.go @@ -1,16 +1,13 @@ package object import ( - "bytes" "context" - "net/http" + "fmt" proto "github.com/isd-sgcu/rpkm67-go-proto/rpkm67/store/object/v1" "github.com/isd-sgcu/rpkm67-store/config" "github.com/isd-sgcu/rpkm67-store/constant" - "github.com/isd-sgcu/rpkm67-store/internal/client/store" - "github.com/isd-sgcu/rpkm67-store/internal/model" - "github.com/minio/minio-go/v7" + "github.com/isd-sgcu/rpkm67-store/internal/utils" "go.uber.org/zap" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -22,62 +19,41 @@ type Service interface { type serviceImpl struct { proto.UnimplementedObjectServiceServer - conf config.Config - repo Repository - log *zap.Logger - storeClient store.Client - httpClient http.Client + conf *config.Store + repo Repository + utils utils.Utils + log *zap.Logger } -func NewService(repo Repository, conf config.Config, storeClient store.Client, httpClient http.Client, log *zap.Logger) proto.ObjectServiceServer { +func NewService(repo Repository, conf *config.Store, log *zap.Logger, utils utils.Utils) Service { return &serviceImpl{ - conf: conf, - repo: repo, - log: log, - storeClient: storeClient, - httpClient: httpClient, + repo: repo, + conf: conf, + utils: utils, + log: log, } } func (s *serviceImpl) Upload(_ context.Context, req *proto.UploadObjectRequest) (*proto.UploadObjectResponse, error) { - if req.Data == nil { - s.log.Named("Upload").Error(constant.FileNotFoundErrorMessage) - return nil, status.Error(codes.NotFound, constant.FileNotFoundErrorMessage) - } - - randomString, err := GenerateRandomString(10) + randomString, err := s.utils.GenerateRandomString(10) if err != nil { s.log.Named("Upload").Error("GenerateRandomString: ", zap.Error(err)) - } - - objectKey := req.Filename + "_" + randomString - buffer := bytes.NewReader(req.Data) - - uploadOutput, err := s.storeClient.Upload(s.conf.Store.BucketName, objectKey, buffer, buffer.Size(), minio.PutObjectOptions{ - ContentType: "application/octet-stream", - }) - - if err != nil { - s.log.Named("Upload").Error("Upload: ", zap.Error(err)) return nil, status.Error(codes.Internal, constant.InternalServerErrorMessage) } - objectResp := &proto.Object{ - Url: s.GetURL(s.conf.Store.BucketName, objectKey), - Key: uploadOutput.Key, - } + objectKey := req.Filename + "_" + randomString - err = s.repo.Upload(&model.Object{ - ImageUrl: objectResp.Url, - ObjectKey: objectResp.Key, - }) + url, key, err := s.repo.Upload(req.Data, s.conf.BucketName, objectKey) if err != nil { s.log.Named("Upload").Error("Upload: ", zap.Error(err)) return nil, status.Error(codes.Internal, constant.InternalServerErrorMessage) } return &proto.UploadObjectResponse{ - Object: objectResp, + Object: &proto.Object{ + Url: url, + Key: key, + }, }, nil } @@ -87,18 +63,20 @@ func (s *serviceImpl) FindByKey(_ context.Context, req *proto.FindByKeyObjectReq return nil, status.Error(codes.InvalidArgument, constant.KeyEmptyErrorMessage) } - object := model.Object{} - - err := s.repo.FindByKey(req.Key, &object) + url, err := s.repo.Get(s.conf.BucketName, req.Key) if err != nil { - s.log.Named("FindByKey").Error("FindByKey: ", zap.Error(err)) + s.log.Named("FindByKey").Error("Get: ", zap.Error(err)) return nil, status.Error(codes.Internal, constant.InternalServerErrorMessage) } + if url == "" { + s.log.Named("FindByKey").Error(fmt.Sprintf("Object with key %v not found", req.Key)) + return nil, status.Error(codes.NotFound, constant.ObjectNotFoundErrorMessage) + } return &proto.FindByKeyObjectResponse{ Object: &proto.Object{ - Url: object.ImageUrl, - Key: object.ObjectKey, + Url: url, + Key: req.Key, }, }, nil } @@ -111,24 +89,19 @@ func (s *serviceImpl) DeleteByKey(_ context.Context, req *proto.DeleteByKeyObjec }, status.Error(codes.InvalidArgument, constant.KeyEmptyErrorMessage) } - err := s.storeClient.DeleteByKey(s.conf.Store.BucketName, req.Key, minio.RemoveObjectOptions{}) + err := s.repo.Delete(s.conf.BucketName, req.Key) if err != nil { - s.log.Named("DeleteByKey").Error("DeleteByKey: ", zap.Error(err)) + s.log.Named("DeleteByKey").Error("Delete: ", zap.Error(err)) return &proto.DeleteByKeyObjectResponse{ Success: false, }, status.Error(codes.Internal, constant.InternalServerErrorMessage) } - err = s.repo.DeleteByKey(req.Key) - if err != nil { - s.log.Named("DeleteByKey").Error("DeleteByKey: ", zap.Error(err)) - } - return &proto.DeleteByKeyObjectResponse{ Success: true, }, nil } func (s *serviceImpl) GetURL(bucketName string, objectKey string) string { - return "https://" + s.conf.Store.Endpoint + "/" + bucketName + "/" + objectKey + return "https://" + s.conf.Endpoint + "/" + bucketName + "/" + objectKey } diff --git a/internal/object/test/object.repository_test.go b/internal/object/test/object.repository_test.go new file mode 100644 index 0000000..f10d94a --- /dev/null +++ b/internal/object/test/object.repository_test.go @@ -0,0 +1,45 @@ +package test + +import ( + "testing" + + "github.com/golang/mock/gomock" + "github.com/isd-sgcu/rpkm67-store/config" + "github.com/isd-sgcu/rpkm67-store/internal/object" + storeClient "github.com/isd-sgcu/rpkm67-store/mocks/client/store" + "github.com/minio/minio-go/v7" + "github.com/stretchr/testify/suite" +) + +type ObjectRepositoryTest struct { + suite.Suite + conf *config.Store + controller *gomock.Controller +} + +func TestObjectRepository(t *testing.T) { + suite.Run(t, new(ObjectRepositoryTest)) +} + +func (t *ObjectRepositoryTest) SetupTest() { + t.conf = &config.Store{ + Endpoint: "mock-endpoint", + } + t.controller = gomock.NewController(t.T()) +} + +func (t *ObjectRepositoryTest) TestCreateObjectSuccess() { + storeClient := storeClient.NewMockClient(t.controller) + storeClient.EXPECT(). + PutObject(gomock.Any(), "mock-bucket", "mock-key", gomock.Any(), int64(0), gomock.Any()). + Return(minio.UploadInfo{ + Key: "mock-key", + }, nil) + + repo := object.NewRepository(t.conf, storeClient, nil) + + url, key, err := repo.Upload([]byte{}, "mock-bucket", "mock-key") + t.Nil(err) + t.Equal("mock-key", key) + t.Equal(repo.GetURL("mock-bucket", "mock-key"), url) +} diff --git a/internal/object/test/object.service_test.go b/internal/object/test/object.service_test.go new file mode 100644 index 0000000..4f69693 --- /dev/null +++ b/internal/object/test/object.service_test.go @@ -0,0 +1,31 @@ +package test + +import ( + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/suite" + "go.uber.org/zap" + + "github.com/isd-sgcu/rpkm67-store/config" +) + +type ObjectServiceTest struct { + suite.Suite + controller *gomock.Controller + conf *config.Store + logger *zap.Logger +} + +func TestObjectService(t *testing.T) { + suite.Run(t, new(ObjectServiceTest)) +} + +func (t *ObjectServiceTest) SetupTest() { + t.controller = gomock.NewController(t.T()) + t.logger = zap.NewNop() + t.conf = &config.Store{ + BucketName: "mock-bucket", + Endpoint: "mock-endpoint", + } +} diff --git a/internal/object/object.utils.go b/internal/utils/random.utils.go similarity index 54% rename from internal/object/object.utils.go rename to internal/utils/random.utils.go index cfd1e88..769de93 100644 --- a/internal/object/object.utils.go +++ b/internal/utils/random.utils.go @@ -1,11 +1,21 @@ -package object +package utils import ( "crypto/rand" "encoding/base64" ) -func GenerateRandomString(length int) (string, error) { +type Utils interface { + GenerateRandomString(length int) (string, error) +} + +type randomUtils struct{} + +func NewRandomUtils() Utils { + return &randomUtils{} +} + +func (u *randomUtils) GenerateRandomString(length int) (string, error) { numBytes := (length * 6) / 8 randomBytes := make([]byte, numBytes) diff --git a/mocks/client/http/http.client.go b/mocks/client/http/http.client.go new file mode 100644 index 0000000..bd409e7 --- /dev/null +++ b/mocks/client/http/http.client.go @@ -0,0 +1,50 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./internal/client/http/http.client.go + +// Package mock_http is a generated GoMock package. +package mock_http + +import ( + http "net/http" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// Get mocks base method. +func (m *MockClient) Get(url string) (*http.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", url) + ret0, _ := ret[0].(*http.Response) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockClientMockRecorder) Get(url interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), url) +} diff --git a/mocks/client/store/store.client.go b/mocks/client/store/store.client.go new file mode 100644 index 0000000..4a25698 --- /dev/null +++ b/mocks/client/store/store.client.go @@ -0,0 +1,66 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./internal/client/store/store.client.go + +// Package mock_store is a generated GoMock package. +package mock_store + +import ( + context "context" + io "io" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + minio "github.com/minio/minio-go/v7" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// PutObject mocks base method. +func (m *MockClient) PutObject(ctx context.Context, bucketName, objectName string, reader io.Reader, objectSize int64, opts minio.PutObjectOptions) (minio.UploadInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutObject", ctx, bucketName, objectName, reader, objectSize, opts) + ret0, _ := ret[0].(minio.UploadInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObject indicates an expected call of PutObject. +func (mr *MockClientMockRecorder) PutObject(ctx, bucketName, objectName, reader, objectSize, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockClient)(nil).PutObject), ctx, bucketName, objectName, reader, objectSize, opts) +} + +// RemoveObject mocks base method. +func (m *MockClient) RemoveObject(ctx context.Context, bucketName, objectName string, opts minio.RemoveObjectOptions) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveObject", ctx, bucketName, objectName, opts) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveObject indicates an expected call of RemoveObject. +func (mr *MockClientMockRecorder) RemoveObject(ctx, bucketName, objectName, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveObject", reflect.TypeOf((*MockClient)(nil).RemoveObject), ctx, bucketName, objectName, opts) +} diff --git a/mocks/object/object.repository.go b/mocks/object/object.repository.go new file mode 100644 index 0000000..994b752 --- /dev/null +++ b/mocks/object/object.repository.go @@ -0,0 +1,93 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./internal/object/object.repository.go + +// Package mock_object is a generated GoMock package. +package mock_object + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockRepository is a mock of Repository interface. +type MockRepository struct { + ctrl *gomock.Controller + recorder *MockRepositoryMockRecorder +} + +// MockRepositoryMockRecorder is the mock recorder for MockRepository. +type MockRepositoryMockRecorder struct { + mock *MockRepository +} + +// NewMockRepository creates a new mock instance. +func NewMockRepository(ctrl *gomock.Controller) *MockRepository { + mock := &MockRepository{ctrl: ctrl} + mock.recorder = &MockRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder { + return m.recorder +} + +// Delete mocks base method. +func (m *MockRepository) Delete(bucketName, objectKey string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", bucketName, objectKey) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockRepositoryMockRecorder) Delete(bucketName, objectKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), bucketName, objectKey) +} + +// Get mocks base method. +func (m *MockRepository) Get(bucketName, objectKey string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", bucketName, objectKey) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockRepositoryMockRecorder) Get(bucketName, objectKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRepository)(nil).Get), bucketName, objectKey) +} + +// GetURL mocks base method. +func (m *MockRepository) GetURL(bucketName, objectKey string) string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetURL", bucketName, objectKey) + ret0, _ := ret[0].(string) + return ret0 +} + +// GetURL indicates an expected call of GetURL. +func (mr *MockRepositoryMockRecorder) GetURL(bucketName, objectKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetURL", reflect.TypeOf((*MockRepository)(nil).GetURL), bucketName, objectKey) +} + +// Upload mocks base method. +func (m *MockRepository) Upload(file []byte, bucketName, objectKey string) (string, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Upload", file, bucketName, objectKey) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// Upload indicates an expected call of Upload. +func (mr *MockRepositoryMockRecorder) Upload(file, bucketName, objectKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockRepository)(nil).Upload), file, bucketName, objectKey) +} diff --git a/mocks/object/object.service.go b/mocks/object/object.service.go new file mode 100644 index 0000000..d1b2e22 --- /dev/null +++ b/mocks/object/object.service.go @@ -0,0 +1,93 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./internal/object/object.service.go + +// Package mock_object is a generated GoMock package. +package mock_object + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + v1 "github.com/isd-sgcu/rpkm67-go-proto/rpkm67/store/object/v1" +) + +// MockService is a mock of Service interface. +type MockService struct { + ctrl *gomock.Controller + recorder *MockServiceMockRecorder +} + +// MockServiceMockRecorder is the mock recorder for MockService. +type MockServiceMockRecorder struct { + mock *MockService +} + +// NewMockService creates a new mock instance. +func NewMockService(ctrl *gomock.Controller) *MockService { + mock := &MockService{ctrl: ctrl} + mock.recorder = &MockServiceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockService) EXPECT() *MockServiceMockRecorder { + return m.recorder +} + +// DeleteByKey mocks base method. +func (m *MockService) DeleteByKey(arg0 context.Context, arg1 *v1.DeleteByKeyObjectRequest) (*v1.DeleteByKeyObjectResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteByKey", arg0, arg1) + ret0, _ := ret[0].(*v1.DeleteByKeyObjectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteByKey indicates an expected call of DeleteByKey. +func (mr *MockServiceMockRecorder) DeleteByKey(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByKey", reflect.TypeOf((*MockService)(nil).DeleteByKey), arg0, arg1) +} + +// FindByKey mocks base method. +func (m *MockService) FindByKey(arg0 context.Context, arg1 *v1.FindByKeyObjectRequest) (*v1.FindByKeyObjectResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FindByKey", arg0, arg1) + ret0, _ := ret[0].(*v1.FindByKeyObjectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FindByKey indicates an expected call of FindByKey. +func (mr *MockServiceMockRecorder) FindByKey(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByKey", reflect.TypeOf((*MockService)(nil).FindByKey), arg0, arg1) +} + +// Upload mocks base method. +func (m *MockService) Upload(arg0 context.Context, arg1 *v1.UploadObjectRequest) (*v1.UploadObjectResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Upload", arg0, arg1) + ret0, _ := ret[0].(*v1.UploadObjectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Upload indicates an expected call of Upload. +func (mr *MockServiceMockRecorder) Upload(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockService)(nil).Upload), arg0, arg1) +} + +// mustEmbedUnimplementedObjectServiceServer mocks base method. +func (m *MockService) mustEmbedUnimplementedObjectServiceServer() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "mustEmbedUnimplementedObjectServiceServer") +} + +// mustEmbedUnimplementedObjectServiceServer indicates an expected call of mustEmbedUnimplementedObjectServiceServer. +func (mr *MockServiceMockRecorder) mustEmbedUnimplementedObjectServiceServer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedObjectServiceServer", reflect.TypeOf((*MockService)(nil).mustEmbedUnimplementedObjectServiceServer)) +} diff --git a/mocks/utils/random/random.utils.go b/mocks/utils/random/random.utils.go new file mode 100644 index 0000000..5be8082 --- /dev/null +++ b/mocks/utils/random/random.utils.go @@ -0,0 +1,49 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./internal/utils/random.utils.go + +// Package mock_utils is a generated GoMock package. +package mock_utils + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockUtils is a mock of Utils interface. +type MockUtils struct { + ctrl *gomock.Controller + recorder *MockUtilsMockRecorder +} + +// MockUtilsMockRecorder is the mock recorder for MockUtils. +type MockUtilsMockRecorder struct { + mock *MockUtils +} + +// NewMockUtils creates a new mock instance. +func NewMockUtils(ctrl *gomock.Controller) *MockUtils { + mock := &MockUtils{ctrl: ctrl} + mock.recorder = &MockUtilsMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUtils) EXPECT() *MockUtilsMockRecorder { + return m.recorder +} + +// GenerateRandomString mocks base method. +func (m *MockUtils) GenerateRandomString(length int) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateRandomString", length) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateRandomString indicates an expected call of GenerateRandomString. +func (mr *MockUtilsMockRecorder) GenerateRandomString(length interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandomString", reflect.TypeOf((*MockUtils)(nil).GenerateRandomString), length) +}