diff --git a/generate_mocks.sh b/generate_mocks.sh index 78f69dd06..cdbe48711 100755 --- a/generate_mocks.sh +++ b/generate_mocks.sh @@ -36,6 +36,7 @@ mockgen -source=policy_set_parameter.go -destination=mocks/policy_set_parameter_ mockgen -source=policy_set_version.go -destination=mocks/policy_set_version_mocks.go -package=mocks mockgen -source=registry_module.go -destination=mocks/registry_module_mocks.go -package=mocks mockgen -source=run.go -destination=mocks/run_mocks.go -package=mocks +mockgen -source=run_task.go -destination=mocks/run_tasks.go -package=mocks mockgen -source=run_trigger.go -destination=mocks/run_trigger_mocks.go -package=mocks mockgen -source=ssh_key.go -destination=mocks/ssh_key_mocks.go -package=mocks mockgen -source=state_version.go -destination=mocks/state_version_mocks.go -package=mocks @@ -49,3 +50,4 @@ mockgen -source=user.go -destination=mocks/user_mocks.go -package=mocks mockgen -source=user_token.go -destination=mocks/user_token_mocks.go -package=mocks mockgen -source=variable.go -destination=mocks/variable_mocks.go -package=mocks mockgen -source=workspace.go -destination=mocks/workspace_mocks.go -package=mocks +mockgen -source=workspace_run_task.go -destination=mocks/workspace_run_tasks.go -package=mocks diff --git a/helper_test.go b/helper_test.go index c3ada891d..6dc820c64 100644 --- a/helper_test.go +++ b/helper_test.go @@ -679,12 +679,17 @@ func createRegistryModuleWithVersion(t *testing.T, client *Client, org *Organiza optionsModuleVersion := RegistryModuleCreateVersionOptions{ Version: String("1.0.0"), } - _, err = client.RegistryModules.CreateVersion(ctx, org.Name, rm.Name, rm.Provider, optionsModuleVersion) + rmID := RegistryModuleID{ + Organization: org.Name, + Name: rm.Name, + Provider: rm.Provider, + } + _, err = client.RegistryModules.CreateVersion(ctx, rmID, optionsModuleVersion) if err != nil { t.Fatal(err) } - rm, err = client.RegistryModules.Read(ctx, org.Name, rm.Name, rm.Provider) + rm, err = client.RegistryModules.Read(ctx, rmID) if err != nil { t.Fatal(err) } diff --git a/mocks/registry_module_mocks.go b/mocks/registry_module_mocks.go index 49c1ee24a..3766db929 100644 --- a/mocks/registry_module_mocks.go +++ b/mocks/registry_module_mocks.go @@ -51,18 +51,18 @@ func (mr *MockRegistryModulesMockRecorder) Create(ctx, organization, options int } // CreateVersion mocks base method. -func (m *MockRegistryModules) CreateVersion(ctx context.Context, organization, name, provider string, options tfe.RegistryModuleCreateVersionOptions) (*tfe.RegistryModuleVersion, error) { +func (m *MockRegistryModules) CreateVersion(ctx context.Context, moduleID tfe.RegistryModuleID, options tfe.RegistryModuleCreateVersionOptions) (*tfe.RegistryModuleVersion, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVersion", ctx, organization, name, provider, options) + ret := m.ctrl.Call(m, "CreateVersion", ctx, moduleID, options) ret0, _ := ret[0].(*tfe.RegistryModuleVersion) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateVersion indicates an expected call of CreateVersion. -func (mr *MockRegistryModulesMockRecorder) CreateVersion(ctx, organization, name, provider, options interface{}) *gomock.Call { +func (mr *MockRegistryModulesMockRecorder) CreateVersion(ctx, moduleID, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVersion", reflect.TypeOf((*MockRegistryModules)(nil).CreateVersion), ctx, organization, name, provider, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVersion", reflect.TypeOf((*MockRegistryModules)(nil).CreateVersion), ctx, moduleID, options) } // CreateWithVCSConnection mocks base method. @@ -95,46 +95,46 @@ func (mr *MockRegistryModulesMockRecorder) Delete(ctx, organization, name interf } // DeleteProvider mocks base method. -func (m *MockRegistryModules) DeleteProvider(ctx context.Context, organization, name, provider string) error { +func (m *MockRegistryModules) DeleteProvider(ctx context.Context, moduleID tfe.RegistryModuleID) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteProvider", ctx, organization, name, provider) + ret := m.ctrl.Call(m, "DeleteProvider", ctx, moduleID) ret0, _ := ret[0].(error) return ret0 } // DeleteProvider indicates an expected call of DeleteProvider. -func (mr *MockRegistryModulesMockRecorder) DeleteProvider(ctx, organization, name, provider interface{}) *gomock.Call { +func (mr *MockRegistryModulesMockRecorder) DeleteProvider(ctx, moduleID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProvider", reflect.TypeOf((*MockRegistryModules)(nil).DeleteProvider), ctx, organization, name, provider) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProvider", reflect.TypeOf((*MockRegistryModules)(nil).DeleteProvider), ctx, moduleID) } // DeleteVersion mocks base method. -func (m *MockRegistryModules) DeleteVersion(ctx context.Context, organization, name, provider, version string) error { +func (m *MockRegistryModules) DeleteVersion(ctx context.Context, moduleID tfe.RegistryModuleID, version string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVersion", ctx, organization, name, provider, version) + ret := m.ctrl.Call(m, "DeleteVersion", ctx, moduleID, version) ret0, _ := ret[0].(error) return ret0 } // DeleteVersion indicates an expected call of DeleteVersion. -func (mr *MockRegistryModulesMockRecorder) DeleteVersion(ctx, organization, name, provider, version interface{}) *gomock.Call { +func (mr *MockRegistryModulesMockRecorder) DeleteVersion(ctx, moduleID, version interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVersion", reflect.TypeOf((*MockRegistryModules)(nil).DeleteVersion), ctx, organization, name, provider, version) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVersion", reflect.TypeOf((*MockRegistryModules)(nil).DeleteVersion), ctx, moduleID, version) } // Read mocks base method. -func (m *MockRegistryModules) Read(ctx context.Context, organization, name, provider string) (*tfe.RegistryModule, error) { +func (m *MockRegistryModules) Read(ctx context.Context, moduleID tfe.RegistryModuleID) (*tfe.RegistryModule, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Read", ctx, organization, name, provider) + ret := m.ctrl.Call(m, "Read", ctx, moduleID) ret0, _ := ret[0].(*tfe.RegistryModule) ret1, _ := ret[1].(error) return ret0, ret1 } // Read indicates an expected call of Read. -func (mr *MockRegistryModulesMockRecorder) Read(ctx, organization, name, provider interface{}) *gomock.Call { +func (mr *MockRegistryModulesMockRecorder) Read(ctx, moduleID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockRegistryModules)(nil).Read), ctx, organization, name, provider) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockRegistryModules)(nil).Read), ctx, moduleID) } // Upload mocks base method. diff --git a/mocks/run_tasks.go b/mocks/run_tasks.go new file mode 100644 index 000000000..5b0485563 --- /dev/null +++ b/mocks/run_tasks.go @@ -0,0 +1,140 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: run_task.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + tfe "github.com/hashicorp/go-tfe" +) + +// MockRunTasks is a mock of RunTasks interface. +type MockRunTasks struct { + ctrl *gomock.Controller + recorder *MockRunTasksMockRecorder +} + +// MockRunTasksMockRecorder is the mock recorder for MockRunTasks. +type MockRunTasksMockRecorder struct { + mock *MockRunTasks +} + +// NewMockRunTasks creates a new mock instance. +func NewMockRunTasks(ctrl *gomock.Controller) *MockRunTasks { + mock := &MockRunTasks{ctrl: ctrl} + mock.recorder = &MockRunTasksMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRunTasks) EXPECT() *MockRunTasksMockRecorder { + return m.recorder +} + +// AttachToWorkspace mocks base method. +func (m *MockRunTasks) AttachToWorkspace(ctx context.Context, workspaceID, runTaskID string, enforcementLevel tfe.TaskEnforcementLevel) (*tfe.WorkspaceRunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachToWorkspace", ctx, workspaceID, runTaskID, enforcementLevel) + ret0, _ := ret[0].(*tfe.WorkspaceRunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachToWorkspace indicates an expected call of AttachToWorkspace. +func (mr *MockRunTasksMockRecorder) AttachToWorkspace(ctx, workspaceID, runTaskID, enforcementLevel interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachToWorkspace", reflect.TypeOf((*MockRunTasks)(nil).AttachToWorkspace), ctx, workspaceID, runTaskID, enforcementLevel) +} + +// Create mocks base method. +func (m *MockRunTasks) Create(ctx context.Context, organization string, options tfe.RunTaskCreateOptions) (*tfe.RunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, organization, options) + ret0, _ := ret[0].(*tfe.RunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockRunTasksMockRecorder) Create(ctx, organization, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRunTasks)(nil).Create), ctx, organization, options) +} + +// Delete mocks base method. +func (m *MockRunTasks) Delete(ctx context.Context, runTaskID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, runTaskID) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockRunTasksMockRecorder) Delete(ctx, runTaskID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRunTasks)(nil).Delete), ctx, runTaskID) +} + +// List mocks base method. +func (m *MockRunTasks) List(ctx context.Context, organization string, options *tfe.RunTaskListOptions) (*tfe.RunTaskList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "List", ctx, organization, options) + ret0, _ := ret[0].(*tfe.RunTaskList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockRunTasksMockRecorder) List(ctx, organization, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRunTasks)(nil).List), ctx, organization, options) +} + +// Read mocks base method. +func (m *MockRunTasks) Read(ctx context.Context, runTaskID string) (*tfe.RunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", ctx, runTaskID) + ret0, _ := ret[0].(*tfe.RunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *MockRunTasksMockRecorder) Read(ctx, runTaskID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockRunTasks)(nil).Read), ctx, runTaskID) +} + +// ReadWithOptions mocks base method. +func (m *MockRunTasks) ReadWithOptions(ctx context.Context, runTaskID string, options *tfe.RunTaskReadOptions) (*tfe.RunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWithOptions", ctx, runTaskID, options) + ret0, _ := ret[0].(*tfe.RunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadWithOptions indicates an expected call of ReadWithOptions. +func (mr *MockRunTasksMockRecorder) ReadWithOptions(ctx, runTaskID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWithOptions", reflect.TypeOf((*MockRunTasks)(nil).ReadWithOptions), ctx, runTaskID, options) +} + +// Update mocks base method. +func (m *MockRunTasks) Update(ctx context.Context, runTaskID string, options tfe.RunTaskUpdateOptions) (*tfe.RunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update", ctx, runTaskID, options) + ret0, _ := ret[0].(*tfe.RunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Update indicates an expected call of Update. +func (mr *MockRunTasksMockRecorder) Update(ctx, runTaskID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRunTasks)(nil).Update), ctx, runTaskID, options) +} diff --git a/mocks/workspace_run_tasks.go b/mocks/workspace_run_tasks.go new file mode 100644 index 000000000..31bde848c --- /dev/null +++ b/mocks/workspace_run_tasks.go @@ -0,0 +1,110 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: workspace_run_task.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + tfe "github.com/hashicorp/go-tfe" +) + +// MockWorkspaceRunTasks is a mock of WorkspaceRunTasks interface. +type MockWorkspaceRunTasks struct { + ctrl *gomock.Controller + recorder *MockWorkspaceRunTasksMockRecorder +} + +// MockWorkspaceRunTasksMockRecorder is the mock recorder for MockWorkspaceRunTasks. +type MockWorkspaceRunTasksMockRecorder struct { + mock *MockWorkspaceRunTasks +} + +// NewMockWorkspaceRunTasks creates a new mock instance. +func NewMockWorkspaceRunTasks(ctrl *gomock.Controller) *MockWorkspaceRunTasks { + mock := &MockWorkspaceRunTasks{ctrl: ctrl} + mock.recorder = &MockWorkspaceRunTasksMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockWorkspaceRunTasks) EXPECT() *MockWorkspaceRunTasksMockRecorder { + return m.recorder +} + +// Create mocks base method. +func (m *MockWorkspaceRunTasks) Create(ctx context.Context, workspaceID string, options tfe.WorkspaceRunTaskCreateOptions) (*tfe.WorkspaceRunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, workspaceID, options) + ret0, _ := ret[0].(*tfe.WorkspaceRunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockWorkspaceRunTasksMockRecorder) Create(ctx, workspaceID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockWorkspaceRunTasks)(nil).Create), ctx, workspaceID, options) +} + +// Delete mocks base method. +func (m *MockWorkspaceRunTasks) Delete(ctx context.Context, workspaceID, workspaceTaskID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, workspaceID, workspaceTaskID) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockWorkspaceRunTasksMockRecorder) Delete(ctx, workspaceID, workspaceTaskID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWorkspaceRunTasks)(nil).Delete), ctx, workspaceID, workspaceTaskID) +} + +// List mocks base method. +func (m *MockWorkspaceRunTasks) List(ctx context.Context, workspaceID string, options *tfe.WorkspaceRunTaskListOptions) (*tfe.WorkspaceRunTaskList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "List", ctx, workspaceID, options) + ret0, _ := ret[0].(*tfe.WorkspaceRunTaskList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockWorkspaceRunTasksMockRecorder) List(ctx, workspaceID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockWorkspaceRunTasks)(nil).List), ctx, workspaceID, options) +} + +// Read mocks base method. +func (m *MockWorkspaceRunTasks) Read(ctx context.Context, workspaceID, workspaceTaskID string) (*tfe.WorkspaceRunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", ctx, workspaceID, workspaceTaskID) + ret0, _ := ret[0].(*tfe.WorkspaceRunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *MockWorkspaceRunTasksMockRecorder) Read(ctx, workspaceID, workspaceTaskID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockWorkspaceRunTasks)(nil).Read), ctx, workspaceID, workspaceTaskID) +} + +// Update mocks base method. +func (m *MockWorkspaceRunTasks) Update(ctx context.Context, workspaceID, workspaceTaskID string, options tfe.WorkspaceRunTaskUpdateOptions) (*tfe.WorkspaceRunTask, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update", ctx, workspaceID, workspaceTaskID, options) + ret0, _ := ret[0].(*tfe.WorkspaceRunTask) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Update indicates an expected call of Update. +func (mr *MockWorkspaceRunTasksMockRecorder) Update(ctx, workspaceID, workspaceTaskID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockWorkspaceRunTasks)(nil).Update), ctx, workspaceID, workspaceTaskID, options) +} diff --git a/registry_module.go b/registry_module.go index 67c4bb66e..af5d568d5 100644 --- a/registry_module.go +++ b/registry_module.go @@ -18,22 +18,22 @@ type RegistryModules interface { Create(ctx context.Context, organization string, options RegistryModuleCreateOptions) (*RegistryModule, error) // Create a registry module version - CreateVersion(ctx context.Context, organization string, name string, provider string, options RegistryModuleCreateVersionOptions) (*RegistryModuleVersion, error) + CreateVersion(ctx context.Context, moduleID RegistryModuleID, options RegistryModuleCreateVersionOptions) (*RegistryModuleVersion, error) // Create and publish a registry module with a VCS repo CreateWithVCSConnection(ctx context.Context, options RegistryModuleCreateWithVCSConnectionOptions) (*RegistryModule, error) // Read a registry module - Read(ctx context.Context, organization string, name string, provider string) (*RegistryModule, error) + Read(ctx context.Context, moduleID RegistryModuleID) (*RegistryModule, error) // Delete a registry module Delete(ctx context.Context, organization string, name string) error // Delete a specific registry module provider - DeleteProvider(ctx context.Context, organization string, name string, provider string) error + DeleteProvider(ctx context.Context, moduleID RegistryModuleID) error // Delete a specific registry module version - DeleteVersion(ctx context.Context, organization string, name string, provider string, version string) error + DeleteVersion(ctx context.Context, moduleID RegistryModuleID, version string) error // Upload Terraform configuration files for the provided registry module version. It // requires a path to the configuration files on disk, which will be packaged by @@ -71,6 +71,16 @@ const ( RegistryModuleVersionStatusOk RegistryModuleVersionStatus = "ok" ) +// RegistryModuleID represents the set of IDs that identify a RegistryModule +type RegistryModuleID struct { + // The organization the module belongs to, see RegistryModule.Organization.Name + Organization string + // The name of the module, see RegistryModule.Name + Name string + // The module's provider, see RegistryModule.Provider + Provider string +} + // RegistryModule represents a registry module type RegistryModule struct { ID string `jsonapi:"primary,registry-modules"` @@ -207,31 +217,20 @@ func (r *registryModules) Create(ctx context.Context, organization string, optio } // CreateVersion creates a new registry module version -func (r *registryModules) CreateVersion(ctx context.Context, organization, name, provider string, options RegistryModuleCreateVersionOptions) (*RegistryModuleVersion, error) { - if !validStringID(&organization) { - return nil, ErrInvalidOrg - } - if !validString(&name) { - return nil, ErrRequiredName - } - if !validStringID(&name) { - return nil, ErrInvalidName - } - if !validString(&provider) { - return nil, ErrRequiredProvider - } - if !validStringID(&provider) { - return nil, ErrInvalidProvider +func (r *registryModules) CreateVersion(ctx context.Context, moduleID RegistryModuleID, options RegistryModuleCreateVersionOptions) (*RegistryModuleVersion, error) { + if err := moduleID.valid(); err != nil { + return nil, err } + if err := options.valid(); err != nil { return nil, err } u := fmt.Sprintf( "registry-modules/%s/%s/%s/versions", - url.QueryEscape(organization), - url.QueryEscape(name), - url.QueryEscape(provider), + url.QueryEscape(moduleID.Organization), + url.QueryEscape(moduleID.Name), + url.QueryEscape(moduleID.Provider), ) req, err := r.client.newRequest("POST", u, &options) if err != nil { @@ -268,28 +267,16 @@ func (r *registryModules) CreateWithVCSConnection(ctx context.Context, options R } // Read a specific registry module -func (r *registryModules) Read(ctx context.Context, organization, name, provider string) (*RegistryModule, error) { - if !validStringID(&organization) { - return nil, ErrInvalidOrg - } - if !validString(&name) { - return nil, ErrRequiredName - } - if !validStringID(&name) { - return nil, ErrInvalidName - } - if !validString(&provider) { - return nil, ErrRequiredProvider - } - if !validStringID(&provider) { - return nil, ErrInvalidProvider +func (r *registryModules) Read(ctx context.Context, moduleID RegistryModuleID) (*RegistryModule, error) { + if err := moduleID.valid(); err != nil { + return nil, err } u := fmt.Sprintf( "registry-modules/show/%s/%s/%s", - url.QueryEscape(organization), - url.QueryEscape(name), - url.QueryEscape(provider), + url.QueryEscape(moduleID.Organization), + url.QueryEscape(moduleID.Name), + url.QueryEscape(moduleID.Provider), ) req, err := r.client.newRequest("GET", u, nil) if err != nil { @@ -331,28 +318,16 @@ func (r *registryModules) Delete(ctx context.Context, organization, name string) } // DeleteProvider is used to delete the specific registry module provider -func (r *registryModules) DeleteProvider(ctx context.Context, organization, name, provider string) error { - if !validStringID(&organization) { - return ErrInvalidOrg - } - if !validString(&name) { - return ErrRequiredName - } - if !validStringID(&name) { - return ErrInvalidName - } - if !validString(&provider) { - return ErrRequiredProvider - } - if !validStringID(&provider) { - return ErrInvalidProvider +func (r *registryModules) DeleteProvider(ctx context.Context, moduleID RegistryModuleID) error { + if err := moduleID.valid(); err != nil { + return err } u := fmt.Sprintf( "registry-modules/actions/delete/%s/%s/%s", - url.QueryEscape(organization), - url.QueryEscape(name), - url.QueryEscape(provider), + url.QueryEscape(moduleID.Organization), + url.QueryEscape(moduleID.Name), + url.QueryEscape(moduleID.Provider), ) req, err := r.client.newRequest("POST", u, nil) if err != nil { @@ -363,21 +338,9 @@ func (r *registryModules) DeleteProvider(ctx context.Context, organization, name } // DeleteVersion is used to delete the specific registry module version -func (r *registryModules) DeleteVersion(ctx context.Context, organization, name, provider, version string) error { - if !validStringID(&organization) { - return ErrInvalidOrg - } - if !validString(&name) { - return ErrRequiredName - } - if !validStringID(&name) { - return ErrInvalidName - } - if !validString(&provider) { - return ErrRequiredProvider - } - if !validStringID(&provider) { - return ErrInvalidProvider +func (r *registryModules) DeleteVersion(ctx context.Context, moduleID RegistryModuleID, version string) error { + if err := moduleID.valid(); err != nil { + return err } if !validString(&version) { return ErrRequiredVersion @@ -388,9 +351,9 @@ func (r *registryModules) DeleteVersion(ctx context.Context, organization, name, u := fmt.Sprintf( "registry-modules/actions/delete/%s/%s/%s/%s", - url.QueryEscape(organization), - url.QueryEscape(name), - url.QueryEscape(provider), + url.QueryEscape(moduleID.Organization), + url.QueryEscape(moduleID.Name), + url.QueryEscape(moduleID.Provider), url.QueryEscape(version), ) req, err := r.client.newRequest("POST", u, nil) @@ -401,6 +364,30 @@ func (r *registryModules) DeleteVersion(ctx context.Context, organization, name, return r.client.do(ctx, req, nil) } +func (o RegistryModuleID) valid() error { + if !validStringID(&o.Organization) { + return ErrInvalidOrg + } + + if !validString(&o.Name) { + return ErrRequiredName + } + + if !validStringID(&o.Name) { + return ErrInvalidName + } + + if !validString(&o.Provider) { + return ErrRequiredProvider + } + + if !validStringID(&o.Provider) { + return ErrInvalidProvider + } + + return nil +} + func (o RegistryModuleCreateOptions) valid() error { if !validString(o.Name) { return ErrRequiredName diff --git a/registry_module_integration_test.go b/registry_module_integration_test.go index c4fa034c1..58cbaee25 100644 --- a/registry_module_integration_test.go +++ b/registry_module_integration_test.go @@ -116,7 +116,12 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, options) + + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, options) require.NoError(t, err) assert.NotEmpty(t, rmv.ID) assert.Equal(t, *options.Version, rmv.Version) @@ -139,7 +144,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { t.Run("with invalid options", func(t *testing.T) { t.Run("without version", func(t *testing.T) { options := RegistryModuleCreateVersionOptions{} - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, options) assert.Nil(t, rmv) assert.Equal(t, err, ErrRequiredVersion) }) @@ -148,7 +157,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("invalid version"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, options) assert.Nil(t, rmv) assert.Equal(t, err, ErrInvalidVersion) }) @@ -158,7 +171,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, "", registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "", + Provider: registryModuleTest.Provider, + }, options) assert.Nil(t, rmv) assert.EqualError(t, err, ErrRequiredName.Error()) }) @@ -167,7 +184,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, badIdentifier, registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: badIdentifier, + Provider: registryModuleTest.Provider, + }, options) assert.Nil(t, rmv) assert.EqualError(t, err, ErrInvalidName.Error()) }) @@ -176,7 +197,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, "", options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: "", + }, options) assert.Nil(t, rmv) assert.Equal(t, err, ErrRequiredProvider) }) @@ -185,7 +210,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, badIdentifier, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: badIdentifier, + }, options) assert.Nil(t, rmv) assert.Equal(t, err, ErrInvalidProvider) }) @@ -194,7 +223,11 @@ func TestRegistryModulesCreateVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, badIdentifier, registryModuleTest.Name, registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: badIdentifier, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, options) assert.Nil(t, rmv) assert.EqualError(t, err, ErrInvalidOrg.Error()) }) @@ -319,7 +352,11 @@ func TestRegistryModulesRead(t *testing.T) { defer registryModuleTestCleanup() t.Run("with valid name and provider", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) require.NoError(t, err) assert.Equal(t, registryModuleTest.ID, rm.ID) @@ -336,37 +373,61 @@ func TestRegistryModulesRead(t *testing.T) { }) t.Run("without a name", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, "", registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "", + Provider: registryModuleTest.Provider, + }) assert.Nil(t, rm) assert.EqualError(t, err, ErrRequiredName.Error()) }) t.Run("with an invalid name", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, badIdentifier, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: badIdentifier, + Provider: registryModuleTest.Provider, + }) assert.Nil(t, rm) assert.EqualError(t, err, ErrInvalidName.Error()) }) t.Run("without a provider", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, "") + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: "", + }) assert.Nil(t, rm) assert.Equal(t, err, ErrRequiredProvider) }) t.Run("with an invalid provider", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, badIdentifier) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: badIdentifier, + }) assert.Nil(t, rm) assert.Equal(t, err, ErrInvalidProvider) }) t.Run("without a valid organization", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, badIdentifier, registryModuleTest.Name, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: badIdentifier, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) assert.Nil(t, rm) assert.EqualError(t, err, ErrInvalidOrg.Error()) }) t.Run("when the registry module does not exist", func(t *testing.T) { - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, "nonexisting", "nonexisting") + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "nonexisting", + Provider: "nonexisting", + }) assert.Nil(t, rm) assert.Error(t, err) }) @@ -385,7 +446,11 @@ func TestRegistryModulesDelete(t *testing.T) { err := client.RegistryModules.Delete(ctx, orgTest.Name, registryModuleTest.Name) require.NoError(t, err) - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) assert.Nil(t, rm) assert.Error(t, err) }) @@ -422,41 +487,73 @@ func TestRegistryModulesDeleteProvider(t *testing.T) { registryModuleTest, _ := createRegistryModule(t, client, orgTest) t.Run("with valid name and provider", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) require.NoError(t, err) - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) assert.Nil(t, rm) assert.Error(t, err) }) t.Run("without a name", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, "", registryModuleTest.Provider) + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "", + Provider: registryModuleTest.Provider, + }) assert.EqualError(t, err, ErrRequiredName.Error()) }) t.Run("with an invalid name", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, badIdentifier, registryModuleTest.Provider) + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: badIdentifier, + Provider: registryModuleTest.Provider, + }) assert.EqualError(t, err, ErrInvalidName.Error()) }) t.Run("without a provider", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, registryModuleTest.Name, "") + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: "", + }) assert.Equal(t, err, ErrRequiredProvider) }) t.Run("with an invalid provider", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, registryModuleTest.Name, badIdentifier) + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: badIdentifier, + }) assert.Equal(t, err, ErrInvalidProvider) }) t.Run("without a valid organization", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, badIdentifier, registryModuleTest.Name, registryModuleTest.Provider) + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: badIdentifier, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) assert.EqualError(t, err, ErrInvalidOrg.Error()) }) t.Run("when the registry module name and provider do not exist", func(t *testing.T) { - err := client.RegistryModules.DeleteProvider(ctx, orgTest.Name, "nonexisting", "nonexisting") + err := client.RegistryModules.DeleteProvider(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "nonexisting", + Provider: "nonexisting", + }) assert.Error(t, err) assert.Equal(t, ErrResourceNotFound, err) }) @@ -476,19 +573,35 @@ func TestRegistryModulesDeleteVersion(t *testing.T) { options := RegistryModuleCreateVersionOptions{ Version: String("1.2.3"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, options) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, options) require.NoError(t, err) require.NotEmpty(t, rmv.Version) - rm, err := client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + rm, err := client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) require.NoError(t, err) require.NotEmpty(t, rm.VersionStatuses) require.Equal(t, 2, len(rm.VersionStatuses)) - err = client.RegistryModules.DeleteVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, rmv.Version) + err = client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, rmv.Version) require.NoError(t, err) - rm, err = client.RegistryModules.Read(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider) + rm, err = client.RegistryModules.Read(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }) require.NoError(t, err) assert.NotEmpty(t, rm.VersionStatuses) assert.Equal(t, 1, len(rm.VersionStatuses)) @@ -497,42 +610,74 @@ func TestRegistryModulesDeleteVersion(t *testing.T) { }) t.Run("without a name", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, "", registryModuleTest.Provider, registryModuleTest.VersionStatuses[0].Version) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "", + Provider: registryModuleTest.Provider, + }, registryModuleTest.VersionStatuses[0].Version) assert.EqualError(t, err, ErrRequiredName.Error()) }) t.Run("with an invalid name", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, badIdentifier, registryModuleTest.Provider, registryModuleTest.VersionStatuses[0].Version) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: badIdentifier, + Provider: registryModuleTest.Provider, + }, registryModuleTest.VersionStatuses[0].Version) assert.EqualError(t, err, ErrInvalidName.Error()) }) t.Run("without a provider", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, registryModuleTest.Name, "", registryModuleTest.VersionStatuses[0].Version) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: "", + }, registryModuleTest.VersionStatuses[0].Version) assert.Equal(t, err, ErrRequiredProvider) }) t.Run("with an invalid provider", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, registryModuleTest.Name, badIdentifier, registryModuleTest.VersionStatuses[0].Version) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: badIdentifier, + }, registryModuleTest.VersionStatuses[0].Version) assert.Equal(t, err, ErrInvalidProvider) }) t.Run("without a version", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, "") + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, "") assert.Equal(t, err, ErrRequiredVersion) }) t.Run("with an invalid version", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, registryModuleTest.Name, registryModuleTest.Provider, badIdentifier) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, badIdentifier) assert.Equal(t, err, ErrInvalidVersion) }) t.Run("without a valid organization", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, badIdentifier, registryModuleTest.Name, registryModuleTest.Provider, registryModuleTest.VersionStatuses[0].Version) + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: badIdentifier, + Name: registryModuleTest.Name, + Provider: registryModuleTest.Provider, + }, registryModuleTest.VersionStatuses[0].Version) assert.EqualError(t, err, ErrInvalidOrg.Error()) }) t.Run("when the registry module name, provider, and version do not exist", func(t *testing.T) { - err := client.RegistryModules.DeleteVersion(ctx, orgTest.Name, "nonexisting", "nonexisting", "2.0.0") + err := client.RegistryModules.DeleteVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: "nonexisting", + Provider: "nonexisting", + }, "2.0.0") assert.Error(t, err) }) } @@ -549,7 +694,11 @@ func TestRegistryModulesUpload(t *testing.T) { optionsModuleVersion := RegistryModuleCreateVersionOptions{ Version: String("1.0.0"), } - rmv, err := client.RegistryModules.CreateVersion(ctx, orgTest.Name, rm.Name, rm.Provider, optionsModuleVersion) + rmv, err := client.RegistryModules.CreateVersion(ctx, RegistryModuleID{ + Organization: orgTest.Name, + Name: rm.Name, + Provider: rm.Provider, + }, optionsModuleVersion) if err != nil { t.Fatal(err) }