diff --git a/Makefile b/Makefile index 1184e5e..3bd59de 100644 --- a/Makefile +++ b/Makefile @@ -74,6 +74,11 @@ clean: generate-mocks: # Mockery version v2.50.0 - @mockery --name=ShellWrapper --dir=wrappers --output=wrappers --outpkg=wrappers --filename=shell_wrapper_mock.go --structname=ShellWrapperMock - @mockery --name=FileSystemWrapper --dir=wrappers --output=wrappers --outpkg=wrappers --filename=file_system_wrapper_mock.go --structname=FileSystemWrapperMock - # @mockery --name=FileSystemWrapper --dir=cmd/wrappers --output=cmd/wrappers --outpkg=wrappers --filename=file_system_repo_mock.go --structname=FileSystemWrapperMock + # Wrapper + @mockery --name=ShellWrapper --dir=wrappers --output=wrappers --outpkg=wrappers --filename=shellWrapper_mock.go --structname=MockShellWrapper + @mockery --name=FileSystemWrapper --dir=wrappers --output=wrappers --outpkg=wrappers --filename=fileSystemWrapper_mock.go --structname=MockFileSystemWrapper + # Repository + @mockery --name=SystemRepo --dir=cmd/repository --output=cmd/repository --outpkg=repository --filename=system_mock.go --structname=MockSystemRepo + @mockery --name=ProjectRepo --dir=cmd/repository --output=cmd/repository --outpkg=repository --filename=project_mock.go --structname=MockProjectRepo + # Helpers + @mockery --name=ProjectHelper --dir=cmd/helpers --output=cmd/helpers --outpkg=helpers --filename=projectHelper_mock.go --structname=MockProjectHelper diff --git a/cmd/helpers/projectHelper_mock.go b/cmd/helpers/projectHelper_mock.go new file mode 100644 index 0000000..5ec7f5e --- /dev/null +++ b/cmd/helpers/projectHelper_mock.go @@ -0,0 +1,243 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package helpers + +import ( + mock "github.com/stretchr/testify/mock" + models "github.com/tech-thinker/gozen/models" +) + +// MockProjectHelper is an autogenerated mock type for the ProjectHelper type +type MockProjectHelper struct { + mock.Mock +} + +// CreateRestAPI provides a mock function with given fields: project +func (_m *MockProjectHelper) CreateRestAPI(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for CreateRestAPI") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// CreategRPCAPI provides a mock function with given fields: project +func (_m *MockProjectHelper) CreategRPCAPI(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for CreategRPCAPI") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// InitProject provides a mock function with given fields: project +func (_m *MockProjectHelper) InitProject(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for InitProject") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupConfig provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupConfig(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupConfig") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupConstants provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupConstants(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupConstants") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupDocker provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupDocker(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupDocker") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupEnv provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupEnv(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupEnv") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupLogger provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupLogger(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupLogger") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupModel provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupModel(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupModel") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupRepository provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupRepository(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupRepository") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupService provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupService(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupService") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SetupUtils provides a mock function with given fields: project +func (_m *MockProjectHelper) SetupUtils(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for SetupUtils") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMockProjectHelper creates a new instance of MockProjectHelper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockProjectHelper(t interface { + mock.TestingT + Cleanup(func()) +}) *MockProjectHelper { + mock := &MockProjectHelper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/cmd/helpers/projectHelper_test.go b/cmd/helpers/projectHelper_test.go new file mode 100644 index 0000000..bf14f4e --- /dev/null +++ b/cmd/helpers/projectHelper_test.go @@ -0,0 +1,817 @@ +package helpers + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/mock" + "github.com/tech-thinker/gozen/cmd/repository" + "github.com/tech-thinker/gozen/models" +) + +func Test_projectHelper_InitProject(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper( + tt.fields.systemRepo, + ) + + if err := h.InitProject(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.InitProject() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupEnv(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupEnv(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupEnv() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupDocker(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupDocker(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupDocker() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupUtils(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupUtils(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupUtils() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupRepository(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupRepository(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupRepository() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupService(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupService(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupService() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupModel(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupModel(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupModel() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupLogger(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupLogger(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupLogger() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupConfig(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupConfig(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupConfig() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_SetupConstants(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("Write", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.SetupConstants(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.SetupConstants() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_CreateRestAPI(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.CreateRestAPI(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.CreateRestAPI() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_projectHelper_CreategRPCAPI(t *testing.T) { + type fields struct { + systemRepo *repository.MockSystemRepo + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if WriteAll success should success", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if WriteAll fail should fail", + fields: fields{}, + prepare: func(f *fields) { + f.systemRepo.On("WriteAll", mock.Anything, mock.Anything, mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + systemRepo: repository.NewMockSystemRepo(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + h := NewProjectHelper(tt.fields.systemRepo) + + if err := h.CreategRPCAPI(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("projectHelper.CreategRPCAPI() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/cmd/repository/project_mock.go b/cmd/repository/project_mock.go new file mode 100644 index 0000000..f0fb49a --- /dev/null +++ b/cmd/repository/project_mock.go @@ -0,0 +1,45 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package repository + +import ( + mock "github.com/stretchr/testify/mock" + models "github.com/tech-thinker/gozen/models" +) + +// MockProjectRepo is an autogenerated mock type for the ProjectRepo type +type MockProjectRepo struct { + mock.Mock +} + +// Create provides a mock function with given fields: project +func (_m *MockProjectRepo) Create(project models.Project) error { + ret := _m.Called(project) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 error + if rf, ok := ret.Get(0).(func(models.Project) error); ok { + r0 = rf(project) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMockProjectRepo creates a new instance of MockProjectRepo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockProjectRepo(t interface { + mock.TestingT + Cleanup(func()) +}) *MockProjectRepo { + mock := &MockProjectRepo{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/cmd/repository/system.go b/cmd/repository/system.go index 3271260..c0202e8 100644 --- a/cmd/repository/system.go +++ b/cmd/repository/system.go @@ -11,10 +11,15 @@ import ( "github.com/tech-thinker/gozen/wrappers" ) +// SystemRepo is an interface that defines methods for interacting with the system. This includes writing files, executing shell commands, and managing the file system. type SystemRepo interface { + // Write generates code from a template and writes it to a file. Write(appDir string, templatePath string, destination string, data interface{}) error + // WriteAll generates code from multiple templates and writes them to their respective files. WriteAll(appDir string, fileConfigs []models.FileConfig, data interface{}) error + // ExecShell executes a shell command with arguments and returns the output as a string slice. ExecShell(command string, args ...string) ([]string, error) + // ExecShellRaw executes a shell command with arguments and returns the raw byte output. ExecShellRaw(command string, args ...string) ([]byte, error) } diff --git a/cmd/repository/system_mock.go b/cmd/repository/system_mock.go new file mode 100644 index 0000000..7072332 --- /dev/null +++ b/cmd/repository/system_mock.go @@ -0,0 +1,137 @@ +// Code generated by mockery v2.50.0. DO NOT EDIT. + +package repository + +import ( + mock "github.com/stretchr/testify/mock" + models "github.com/tech-thinker/gozen/models" +) + +// MockSystemRepo is an autogenerated mock type for the SystemRepo type +type MockSystemRepo struct { + mock.Mock +} + +// ExecShell provides a mock function with given fields: command, args +func (_m *MockSystemRepo) ExecShell(command string, args ...string) ([]string, error) { + _va := make([]interface{}, len(args)) + for _i := range args { + _va[_i] = args[_i] + } + var _ca []interface{} + _ca = append(_ca, command) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ExecShell") + } + + var r0 []string + var r1 error + if rf, ok := ret.Get(0).(func(string, ...string) ([]string, error)); ok { + return rf(command, args...) + } + if rf, ok := ret.Get(0).(func(string, ...string) []string); ok { + r0 = rf(command, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func(string, ...string) error); ok { + r1 = rf(command, args...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ExecShellRaw provides a mock function with given fields: command, args +func (_m *MockSystemRepo) ExecShellRaw(command string, args ...string) ([]byte, error) { + _va := make([]interface{}, len(args)) + for _i := range args { + _va[_i] = args[_i] + } + var _ca []interface{} + _ca = append(_ca, command) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ExecShellRaw") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(string, ...string) ([]byte, error)); ok { + return rf(command, args...) + } + if rf, ok := ret.Get(0).(func(string, ...string) []byte); ok { + r0 = rf(command, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func(string, ...string) error); ok { + r1 = rf(command, args...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Write provides a mock function with given fields: appDir, templatePath, destination, data +func (_m *MockSystemRepo) Write(appDir string, templatePath string, destination string, data interface{}) error { + ret := _m.Called(appDir, templatePath, destination, data) + + if len(ret) == 0 { + panic("no return value specified for Write") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string, string, interface{}) error); ok { + r0 = rf(appDir, templatePath, destination, data) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// WriteAll provides a mock function with given fields: appDir, fileConfigs, data +func (_m *MockSystemRepo) WriteAll(appDir string, fileConfigs []models.FileConfig, data interface{}) error { + ret := _m.Called(appDir, fileConfigs, data) + + if len(ret) == 0 { + panic("no return value specified for WriteAll") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, []models.FileConfig, interface{}) error); ok { + r0 = rf(appDir, fileConfigs, data) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMockSystemRepo creates a new instance of MockSystemRepo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSystemRepo(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSystemRepo { + mock := &MockSystemRepo{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/cmd/repository/system_test.go b/cmd/repository/system_test.go index 420f8c0..631988b 100644 --- a/cmd/repository/system_test.go +++ b/cmd/repository/system_test.go @@ -15,8 +15,8 @@ import ( func Test_systemRepo_Write(t *testing.T) { type fields struct { templatesFS embed.FS - shellWrapper *wrappers.ShellWrapperMock - fileSystemWrapper *wrappers.FileSystemWrapperMock + shellWrapper *wrappers.MockShellWrapper + fileSystemWrapper *wrappers.MockFileSystemWrapper } type args struct { appDir string @@ -95,8 +95,8 @@ func Test_systemRepo_Write(t *testing.T) { // Preparing mocks tt.fields = fields{ templatesFS: utils.GetMockTmpl(), - shellWrapper: wrappers.NewShellWrapperMock(t), - fileSystemWrapper: wrappers.NewFileSystemWrapperMock(t), + shellWrapper: wrappers.NewMockShellWrapper(t), + fileSystemWrapper: wrappers.NewMockFileSystemWrapper(t), } if tt.prepare != nil { @@ -118,8 +118,8 @@ func Test_systemRepo_Write(t *testing.T) { func Test_systemRepo_WriteAll(t *testing.T) { type fields struct { templatesFS embed.FS - shellWrapper *wrappers.ShellWrapperMock - fileSystemWrapper *wrappers.FileSystemWrapperMock + shellWrapper *wrappers.MockShellWrapper + fileSystemWrapper *wrappers.MockFileSystemWrapper } type args struct { appDir string @@ -201,8 +201,8 @@ func Test_systemRepo_WriteAll(t *testing.T) { // Preparing mocks tt.fields = fields{ templatesFS: utils.GetMockTmpl(), - shellWrapper: wrappers.NewShellWrapperMock(t), - fileSystemWrapper: wrappers.NewFileSystemWrapperMock(t), + shellWrapper: wrappers.NewMockShellWrapper(t), + fileSystemWrapper: wrappers.NewMockFileSystemWrapper(t), } if tt.prepare != nil { @@ -224,8 +224,8 @@ func Test_systemRepo_WriteAll(t *testing.T) { func Test_systemRepo_ExecShell(t *testing.T) { type fields struct { templatesFS embed.FS - shellWrapper *wrappers.ShellWrapperMock - fileSystemWrapper *wrappers.FileSystemWrapperMock + shellWrapper *wrappers.MockShellWrapper + fileSystemWrapper *wrappers.MockFileSystemWrapper } type args struct { command string @@ -270,8 +270,8 @@ func Test_systemRepo_ExecShell(t *testing.T) { // Preparing mocks tt.fields = fields{ templatesFS: utils.GetMockTmpl(), - shellWrapper: wrappers.NewShellWrapperMock(t), - fileSystemWrapper: wrappers.NewFileSystemWrapperMock(t), + shellWrapper: wrappers.NewMockShellWrapper(t), + fileSystemWrapper: wrappers.NewMockFileSystemWrapper(t), } if tt.prepare != nil { @@ -298,8 +298,8 @@ func Test_systemRepo_ExecShell(t *testing.T) { func Test_systemRepo_ExecShellRaw(t *testing.T) { type fields struct { templatesFS embed.FS - shellWrapper *wrappers.ShellWrapperMock - fileSystemWrapper *wrappers.FileSystemWrapperMock + shellWrapper *wrappers.MockShellWrapper + fileSystemWrapper *wrappers.MockFileSystemWrapper } type args struct { command string @@ -343,8 +343,8 @@ func Test_systemRepo_ExecShellRaw(t *testing.T) { // Preparing mocks tt.fields = fields{ templatesFS: utils.GetMockTmpl(), - shellWrapper: wrappers.NewShellWrapperMock(t), - fileSystemWrapper: wrappers.NewFileSystemWrapperMock(t), + shellWrapper: wrappers.NewMockShellWrapper(t), + fileSystemWrapper: wrappers.NewMockFileSystemWrapper(t), } if tt.prepare != nil { diff --git a/cmd/service/createApp.go b/cmd/service/createApp.go index 9f71b99..b84b396 100644 --- a/cmd/service/createApp.go +++ b/cmd/service/createApp.go @@ -11,20 +11,23 @@ type AppService interface { } type appService struct { - systemRepo repository.SystemRepo projectRepo repository.ProjectRepo projectHelper helpers.ProjectHelper } func (cmd *appService) CreateApp(project models.Project) error { // Create project - cmd.projectRepo.Create(project) + err := cmd.projectRepo.Create(project) + if err != nil { + return err + } // Generating basic codes - err := cmd.projectHelper.InitProject(project) + err = cmd.projectHelper.InitProject(project) if err != nil { return err } + err = cmd.projectHelper.SetupEnv(project) if err != nil { return err @@ -67,6 +70,9 @@ func (cmd *appService) CreateApp(project models.Project) error { } // Utils err = cmd.projectHelper.SetupUtils(project) + if err != nil { + return err + } // Rest err = cmd.projectHelper.CreateRestAPI(project) @@ -83,12 +89,10 @@ func (cmd *appService) CreateApp(project models.Project) error { } func NewAppService( - systemRepo repository.SystemRepo, projectRepo repository.ProjectRepo, projectHelper helpers.ProjectHelper, ) AppService { return &appService{ - systemRepo: systemRepo, projectRepo: projectRepo, projectHelper: projectHelper, } diff --git a/cmd/service/createApp_test.go b/cmd/service/createApp_test.go new file mode 100644 index 0000000..fbda783 --- /dev/null +++ b/cmd/service/createApp_test.go @@ -0,0 +1,364 @@ +package service + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/mock" + "github.com/tech-thinker/gozen/cmd/helpers" + "github.com/tech-thinker/gozen/cmd/repository" + "github.com/tech-thinker/gozen/models" +) + +func Test_appService_CreateApp(t *testing.T) { + type fields struct { + projectRepo *repository.MockProjectRepo + projectHelper *helpers.MockProjectHelper + } + type args struct { + project models.Project + } + tests := []struct { + name string + fields fields + prepare func(f *fields) + args args + wantErr bool + }{ + { + name: "if create project and helper success then should success", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(nil) + f.projectHelper.On("SetupService", mock.Anything).Return(nil) + f.projectHelper.On("SetupUtils", mock.Anything).Return(nil) + f.projectHelper.On("CreateRestAPI", mock.Anything).Return(nil) + f.projectHelper.On("CreategRPCAPI", mock.Anything).Return(nil) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: false, + }, + { + name: "if create fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if InitProject fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupEnv fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupDocker fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupConfig fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupConstants fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupLogger fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupModel fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupRepository fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupService fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(nil) + f.projectHelper.On("SetupService", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if SetupUtils fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(nil) + f.projectHelper.On("SetupService", mock.Anything).Return(nil) + f.projectHelper.On("SetupUtils", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if CreateRestAPI fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(nil) + f.projectHelper.On("SetupService", mock.Anything).Return(nil) + f.projectHelper.On("SetupUtils", mock.Anything).Return(nil) + f.projectHelper.On("CreateRestAPI", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + { + name: "if CreategRPCAPI fail then should fail", + fields: fields{}, + prepare: func(f *fields) { + f.projectRepo.On("Create", mock.Anything).Return(nil) + f.projectHelper.On("InitProject", mock.Anything).Return(nil) + f.projectHelper.On("SetupEnv", mock.Anything).Return(nil) + f.projectHelper.On("SetupDocker", mock.Anything).Return(nil) + f.projectHelper.On("SetupConfig", mock.Anything).Return(nil) + f.projectHelper.On("SetupConstants", mock.Anything).Return(nil) + f.projectHelper.On("SetupLogger", mock.Anything).Return(nil) + f.projectHelper.On("SetupModel", mock.Anything).Return(nil) + f.projectHelper.On("SetupRepository", mock.Anything).Return(nil) + f.projectHelper.On("SetupService", mock.Anything).Return(nil) + f.projectHelper.On("SetupUtils", mock.Anything).Return(nil) + f.projectHelper.On("CreateRestAPI", mock.Anything).Return(nil) + f.projectHelper.On("CreategRPCAPI", mock.Anything).Return(errors.New(`error`)) + }, + args: args{ + project: models.Project{ + AppName: "test", + PackageName: "test", + Driver: "postgres", + WorkingDir: ".", + }, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + tt.fields = fields{ + projectRepo: repository.NewMockProjectRepo(t), + projectHelper: helpers.NewMockProjectHelper(t), + } + + if tt.prepare != nil { + tt.prepare(&tt.fields) + } + + cmd := NewAppService( + tt.fields.projectRepo, + tt.fields.projectHelper, + ) + if err := cmd.CreateApp(tt.args.project); (err != nil) != tt.wantErr { + t.Errorf("appService.CreateApp() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/main.go b/main.go index 673d465..81d22be 100644 --- a/main.go +++ b/main.go @@ -35,7 +35,7 @@ func main() { projectHelper := helpers.NewProjectHelper(systemRepo) - appSvc := service.NewAppService(systemRepo, projectRepo, projectHelper) + appSvc := service.NewAppService(projectRepo, projectHelper) app := cmd.NewApp(appSvc) cliApp := cli.NewApp() diff --git a/wrappers/fileSystemWrapper_mock.go b/wrappers/fileSystemWrapper_mock.go index adf4fe6..341a353 100644 --- a/wrappers/fileSystemWrapper_mock.go +++ b/wrappers/fileSystemWrapper_mock.go @@ -4,13 +4,13 @@ package wrappers import mock "github.com/stretchr/testify/mock" -// FileSystemWrapperMock is an autogenerated mock type for the FileSystemWrapper type -type FileSystemWrapperMock struct { +// MockFileSystemWrapper is an autogenerated mock type for the FileSystemWrapper type +type MockFileSystemWrapper struct { mock.Mock } // CreateDirectory provides a mock function with given fields: path -func (_m *FileSystemWrapperMock) CreateDirectory(path string) error { +func (_m *MockFileSystemWrapper) CreateDirectory(path string) error { ret := _m.Called(path) if len(ret) == 0 { @@ -28,7 +28,7 @@ func (_m *FileSystemWrapperMock) CreateDirectory(path string) error { } // Destroy provides a mock function with given fields: path -func (_m *FileSystemWrapperMock) Destroy(path string) error { +func (_m *MockFileSystemWrapper) Destroy(path string) error { ret := _m.Called(path) if len(ret) == 0 { @@ -46,7 +46,7 @@ func (_m *FileSystemWrapperMock) Destroy(path string) error { } // WriteFile provides a mock function with given fields: path, data -func (_m *FileSystemWrapperMock) WriteFile(path string, data string) error { +func (_m *MockFileSystemWrapper) WriteFile(path string, data string) error { ret := _m.Called(path, data) if len(ret) == 0 { @@ -63,13 +63,13 @@ func (_m *FileSystemWrapperMock) WriteFile(path string, data string) error { return r0 } -// NewFileSystemWrapperMock creates a new instance of FileSystemWrapperMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// NewMockFileSystemWrapper creates a new instance of MockFileSystemWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. -func NewFileSystemWrapperMock(t interface { +func NewMockFileSystemWrapper(t interface { mock.TestingT Cleanup(func()) -}) *FileSystemWrapperMock { - mock := &FileSystemWrapperMock{} +}) *MockFileSystemWrapper { + mock := &MockFileSystemWrapper{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) }) diff --git a/wrappers/shellWrapper_mock.go b/wrappers/shellWrapper_mock.go index fc86000..73b09f4 100644 --- a/wrappers/shellWrapper_mock.go +++ b/wrappers/shellWrapper_mock.go @@ -4,13 +4,13 @@ package wrappers import mock "github.com/stretchr/testify/mock" -// ShellWrapperMock is an autogenerated mock type for the ShellWrapper type -type ShellWrapperMock struct { +// MockShellWrapper is an autogenerated mock type for the ShellWrapper type +type MockShellWrapper struct { mock.Mock } // Exec provides a mock function with given fields: name, args -func (_m *ShellWrapperMock) Exec(name string, args ...string) ([]byte, error) { +func (_m *MockShellWrapper) Exec(name string, args ...string) ([]byte, error) { _va := make([]interface{}, len(args)) for _i := range args { _va[_i] = args[_i] @@ -46,13 +46,13 @@ func (_m *ShellWrapperMock) Exec(name string, args ...string) ([]byte, error) { return r0, r1 } -// NewShellWrapperMock creates a new instance of ShellWrapperMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// NewMockShellWrapper creates a new instance of MockShellWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. -func NewShellWrapperMock(t interface { +func NewMockShellWrapper(t interface { mock.TestingT Cleanup(func()) -}) *ShellWrapperMock { - mock := &ShellWrapperMock{} +}) *MockShellWrapper { + mock := &MockShellWrapper{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) })