From 9384e37bb1eb1fcc2adf94c82cd26724e060308c Mon Sep 17 00:00:00 2001 From: Gabriel Adrian Samfira Date: Thu, 28 Mar 2024 18:23:49 +0000 Subject: [PATCH] Fix tests Signed-off-by: Gabriel Adrian Samfira --- database/common/common.go | 38 ++--- database/common/mocks/Store.go | 258 ++++++++++++++--------------- database/sql/enterprise.go | 14 +- database/sql/enterprise_test.go | 77 +++++++-- database/sql/instances.go | 8 +- database/sql/instances_test.go | 6 +- database/sql/organizations.go | 14 +- database/sql/organizations_test.go | 77 +++++++-- database/sql/pools.go | 70 ++++++-- database/sql/pools_test.go | 8 +- database/sql/repositories.go | 14 +- database/sql/repositories_test.go | 77 +++++++-- database/sql/util.go | 35 +++- runner/enterprises.go | 42 ++--- runner/enterprises_test.go | 67 +++++--- runner/organizations.go | 41 +++-- runner/organizations_test.go | 65 +++++--- runner/pool/pool.go | 11 +- runner/pools_test.go | 8 +- runner/repositories.go | 40 +++-- runner/repositories_test.go | 73 +++++--- runner/runner.go | 5 +- 22 files changed, 652 insertions(+), 396 deletions(-) diff --git a/database/common/common.go b/database/common/common.go index 1bd4c437..ab546844 100644 --- a/database/common/common.go +++ b/database/common/common.go @@ -28,9 +28,9 @@ type RepoStore interface { DeleteRepository(ctx context.Context, repoID string) error UpdateRepository(ctx context.Context, repoID string, param params.UpdateEntityParams) (params.Repository, error) - CreateRepositoryPool(ctx context.Context, repoID string, param params.CreatePoolParams) (params.Pool, error) - GetRepositoryPool(ctx context.Context, repoID, poolID string) (params.Pool, error) - DeleteRepositoryPool(ctx context.Context, repoID, poolID string) error + // CreateRepositoryPool(ctx context.Context, repoID string, param params.CreatePoolParams) (params.Pool, error) + // GetRepositoryPool(ctx context.Context, repoID, poolID string) (params.Pool, error) + // DeleteRepositoryPool(ctx context.Context, repoID, poolID string) error UpdateRepositoryPool(ctx context.Context, repoID, poolID string, param params.UpdatePoolParams) (params.Pool, error) ListRepoPools(ctx context.Context, repoID string) ([]params.Pool, error) @@ -45,25 +45,15 @@ type OrgStore interface { DeleteOrganization(ctx context.Context, orgID string) error UpdateOrganization(ctx context.Context, orgID string, param params.UpdateEntityParams) (params.Organization, error) - CreateOrganizationPool(ctx context.Context, orgID string, param params.CreatePoolParams) (params.Pool, error) - GetOrganizationPool(ctx context.Context, orgID, poolID string) (params.Pool, error) - DeleteOrganizationPool(ctx context.Context, orgID, poolID string) error + // CreateOrganizationPool(ctx context.Context, orgID string, param params.CreatePoolParams) (params.Pool, error) + // GetOrganizationPool(ctx context.Context, orgID, poolID string) (params.Pool, error) + // DeleteOrganizationPool(ctx context.Context, orgID, poolID string) error UpdateOrganizationPool(ctx context.Context, orgID, poolID string, param params.UpdatePoolParams) (params.Pool, error) ListOrgPools(ctx context.Context, orgID string) ([]params.Pool, error) ListOrgInstances(ctx context.Context, orgID string) ([]params.Instance, error) } -type EntityPools interface { - CreateEntityPool(ctx context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) - GetEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) - DeleteEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) error - UpdateEntityPool(ctx context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) - - ListEntityPools(ctx context.Context, entity params.GithubEntity) ([]params.Pool, error) - ListEntityInstances(ctx context.Context, entity params.GithubEntity) ([]params.Instance, error) -} - type EnterpriseStore interface { CreateEnterprise(ctx context.Context, name, credentialsName, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Enterprise, error) GetEnterprise(ctx context.Context, name string) (params.Enterprise, error) @@ -72,9 +62,9 @@ type EnterpriseStore interface { DeleteEnterprise(ctx context.Context, enterpriseID string) error UpdateEnterprise(ctx context.Context, enterpriseID string, param params.UpdateEntityParams) (params.Enterprise, error) - CreateEnterprisePool(ctx context.Context, enterpriseID string, param params.CreatePoolParams) (params.Pool, error) - GetEnterprisePool(ctx context.Context, enterpriseID, poolID string) (params.Pool, error) - DeleteEnterprisePool(ctx context.Context, enterpriseID, poolID string) error + // CreateEnterprisePool(ctx context.Context, enterpriseID string, param params.CreatePoolParams) (params.Pool, error) + // GetEnterprisePool(ctx context.Context, enterpriseID, poolID string) (params.Pool, error) + // DeleteEnterprisePool(ctx context.Context, enterpriseID, poolID string) error UpdateEnterprisePool(ctx context.Context, enterpriseID, poolID string, param params.UpdatePoolParams) (params.Pool, error) ListEnterprisePools(ctx context.Context, enterpriseID string) ([]params.Pool, error) @@ -136,6 +126,16 @@ type JobsStore interface { DeleteCompletedJobs(ctx context.Context) error } +type EntityPools interface { + CreateEntityPool(ctx context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) + GetEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) + DeleteEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) error + UpdateEntityPool(ctx context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) + + ListEntityPools(ctx context.Context, entity params.GithubEntity) ([]params.Pool, error) + ListEntityInstances(ctx context.Context, entity params.GithubEntity) ([]params.Instance, error) +} + //go:generate mockery --name=Store type Store interface { RepoStore diff --git a/database/common/mocks/Store.go b/database/common/mocks/Store.go index e6f6d815..73eef2c3 100644 --- a/database/common/mocks/Store.go +++ b/database/common/mocks/Store.go @@ -106,27 +106,27 @@ func (_m *Store) CreateEnterprise(ctx context.Context, name string, credentialsN return r0, r1 } -// CreateEnterprisePool provides a mock function with given fields: ctx, enterpriseID, param -func (_m *Store) CreateEnterprisePool(ctx context.Context, enterpriseID string, param params.CreatePoolParams) (params.Pool, error) { - ret := _m.Called(ctx, enterpriseID, param) +// CreateEntityPool provides a mock function with given fields: ctx, entity, param +func (_m *Store) CreateEntityPool(ctx context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) { + ret := _m.Called(ctx, entity, param) if len(ret) == 0 { - panic("no return value specified for CreateEnterprisePool") + panic("no return value specified for CreateEntityPool") } var r0 params.Pool var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok { - return rf(ctx, enterpriseID, param) + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, params.CreatePoolParams) (params.Pool, error)); ok { + return rf(ctx, entity, param) } - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok { - r0 = rf(ctx, enterpriseID, param) + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, params.CreatePoolParams) params.Pool); ok { + r0 = rf(ctx, entity, param) } else { r0 = ret.Get(0).(params.Pool) } - if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok { - r1 = rf(ctx, enterpriseID, param) + if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, params.CreatePoolParams) error); ok { + r1 = rf(ctx, entity, param) } else { r1 = ret.Error(1) } @@ -218,34 +218,6 @@ func (_m *Store) CreateOrganization(ctx context.Context, name string, credential return r0, r1 } -// CreateOrganizationPool provides a mock function with given fields: ctx, orgID, param -func (_m *Store) CreateOrganizationPool(ctx context.Context, orgID string, param params.CreatePoolParams) (params.Pool, error) { - ret := _m.Called(ctx, orgID, param) - - if len(ret) == 0 { - panic("no return value specified for CreateOrganizationPool") - } - - var r0 params.Pool - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok { - return rf(ctx, orgID, param) - } - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok { - r0 = rf(ctx, orgID, param) - } else { - r0 = ret.Get(0).(params.Pool) - } - - if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok { - r1 = rf(ctx, orgID, param) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // CreateRepository provides a mock function with given fields: ctx, owner, name, credentialsName, webhookSecret, poolBalancerType func (_m *Store) CreateRepository(ctx context.Context, owner string, name string, credentialsName string, webhookSecret string, poolBalancerType params.PoolBalancerType) (params.Repository, error) { ret := _m.Called(ctx, owner, name, credentialsName, webhookSecret, poolBalancerType) @@ -274,34 +246,6 @@ func (_m *Store) CreateRepository(ctx context.Context, owner string, name string return r0, r1 } -// CreateRepositoryPool provides a mock function with given fields: ctx, repoID, param -func (_m *Store) CreateRepositoryPool(ctx context.Context, repoID string, param params.CreatePoolParams) (params.Pool, error) { - ret := _m.Called(ctx, repoID, param) - - if len(ret) == 0 { - panic("no return value specified for CreateRepositoryPool") - } - - var r0 params.Pool - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok { - return rf(ctx, repoID, param) - } - if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok { - r0 = rf(ctx, repoID, param) - } else { - r0 = ret.Get(0).(params.Pool) - } - - if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok { - r1 = rf(ctx, repoID, param) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // CreateUser provides a mock function with given fields: ctx, user func (_m *Store) CreateUser(ctx context.Context, user params.NewUserParams) (params.User, error) { ret := _m.Called(ctx, user) @@ -384,6 +328,24 @@ func (_m *Store) DeleteEnterprisePool(ctx context.Context, enterpriseID string, return r0 } +// DeleteEntityPool provides a mock function with given fields: ctx, entity, poolID +func (_m *Store) DeleteEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) error { + ret := _m.Called(ctx, entity, poolID) + + if len(ret) == 0 { + panic("no return value specified for DeleteEntityPool") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) error); ok { + r0 = rf(ctx, entity, poolID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + // DeleteInstance provides a mock function with given fields: ctx, poolID, instanceName func (_m *Store) DeleteInstance(ctx context.Context, poolID string, instanceName string) error { ret := _m.Called(ctx, poolID, instanceName) @@ -596,27 +558,27 @@ func (_m *Store) GetEnterpriseByID(ctx context.Context, enterpriseID string) (pa return r0, r1 } -// GetEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID -func (_m *Store) GetEnterprisePool(ctx context.Context, enterpriseID string, poolID string) (params.Pool, error) { - ret := _m.Called(ctx, enterpriseID, poolID) +// GetEntityPool provides a mock function with given fields: ctx, entity, poolID +func (_m *Store) GetEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) { + ret := _m.Called(ctx, entity, poolID) if len(ret) == 0 { - panic("no return value specified for GetEnterprisePool") + panic("no return value specified for GetEntityPool") } var r0 params.Pool var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok { - return rf(ctx, enterpriseID, poolID) + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) (params.Pool, error)); ok { + return rf(ctx, entity, poolID) } - if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok { - r0 = rf(ctx, enterpriseID, poolID) + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string) params.Pool); ok { + r0 = rf(ctx, entity, poolID) } else { r0 = ret.Get(0).(params.Pool) } - if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { - r1 = rf(ctx, enterpriseID, poolID) + if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, string) error); ok { + r1 = rf(ctx, entity, poolID) } else { r1 = ret.Error(1) } @@ -736,34 +698,6 @@ func (_m *Store) GetOrganizationByID(ctx context.Context, orgID string) (params. return r0, r1 } -// GetOrganizationPool provides a mock function with given fields: ctx, orgID, poolID -func (_m *Store) GetOrganizationPool(ctx context.Context, orgID string, poolID string) (params.Pool, error) { - ret := _m.Called(ctx, orgID, poolID) - - if len(ret) == 0 { - panic("no return value specified for GetOrganizationPool") - } - - var r0 params.Pool - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok { - return rf(ctx, orgID, poolID) - } - if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok { - r0 = rf(ctx, orgID, poolID) - } else { - r0 = ret.Get(0).(params.Pool) - } - - if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { - r1 = rf(ctx, orgID, poolID) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // GetPoolByID provides a mock function with given fields: ctx, poolID func (_m *Store) GetPoolByID(ctx context.Context, poolID string) (params.Pool, error) { ret := _m.Called(ctx, poolID) @@ -876,34 +810,6 @@ func (_m *Store) GetRepositoryByID(ctx context.Context, repoID string) (params.R return r0, r1 } -// GetRepositoryPool provides a mock function with given fields: ctx, repoID, poolID -func (_m *Store) GetRepositoryPool(ctx context.Context, repoID string, poolID string) (params.Pool, error) { - ret := _m.Called(ctx, repoID, poolID) - - if len(ret) == 0 { - panic("no return value specified for GetRepositoryPool") - } - - var r0 params.Pool - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok { - return rf(ctx, repoID, poolID) - } - if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok { - r0 = rf(ctx, repoID, poolID) - } else { - r0 = ret.Get(0).(params.Pool) - } - - if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { - r1 = rf(ctx, repoID, poolID) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // GetUser provides a mock function with given fields: ctx, user func (_m *Store) GetUser(ctx context.Context, user string) (params.User, error) { ret := _m.Called(ctx, user) @@ -1186,6 +1092,36 @@ func (_m *Store) ListEnterprises(ctx context.Context) ([]params.Enterprise, erro return r0, r1 } +// ListEntityInstances provides a mock function with given fields: ctx, entity +func (_m *Store) ListEntityInstances(ctx context.Context, entity params.GithubEntity) ([]params.Instance, error) { + ret := _m.Called(ctx, entity) + + if len(ret) == 0 { + panic("no return value specified for ListEntityInstances") + } + + var r0 []params.Instance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) ([]params.Instance, error)); ok { + return rf(ctx, entity) + } + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) []params.Instance); ok { + r0 = rf(ctx, entity) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]params.Instance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity) error); ok { + r1 = rf(ctx, entity) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // ListEntityJobsByStatus provides a mock function with given fields: ctx, entityType, entityID, status func (_m *Store) ListEntityJobsByStatus(ctx context.Context, entityType params.GithubEntityType, entityID string, status params.JobStatus) ([]params.Job, error) { ret := _m.Called(ctx, entityType, entityID, status) @@ -1216,6 +1152,36 @@ func (_m *Store) ListEntityJobsByStatus(ctx context.Context, entityType params.G return r0, r1 } +// ListEntityPools provides a mock function with given fields: ctx, entity +func (_m *Store) ListEntityPools(ctx context.Context, entity params.GithubEntity) ([]params.Pool, error) { + ret := _m.Called(ctx, entity) + + if len(ret) == 0 { + panic("no return value specified for ListEntityPools") + } + + var r0 []params.Pool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) ([]params.Pool, error)); ok { + return rf(ctx, entity) + } + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity) []params.Pool); ok { + r0 = rf(ctx, entity) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]params.Pool) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity) error); ok { + r1 = rf(ctx, entity) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // ListInstanceEvents provides a mock function with given fields: ctx, instanceID, eventType, eventLevel func (_m *Store) ListInstanceEvents(ctx context.Context, instanceID string, eventType params.EventType, eventLevel params.EventLevel) ([]params.StatusMessage, error) { ret := _m.Called(ctx, instanceID, eventType, eventLevel) @@ -1606,6 +1572,34 @@ func (_m *Store) UpdateEnterprisePool(ctx context.Context, enterpriseID string, return r0, r1 } +// UpdateEntityPool provides a mock function with given fields: ctx, entity, poolID, param +func (_m *Store) UpdateEntityPool(ctx context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) { + ret := _m.Called(ctx, entity, poolID, param) + + if len(ret) == 0 { + panic("no return value specified for UpdateEntityPool") + } + + var r0 params.Pool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) (params.Pool, error)); ok { + return rf(ctx, entity, poolID, param) + } + if rf, ok := ret.Get(0).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) params.Pool); ok { + r0 = rf(ctx, entity, poolID, param) + } else { + r0 = ret.Get(0).(params.Pool) + } + + if rf, ok := ret.Get(1).(func(context.Context, params.GithubEntity, string, params.UpdatePoolParams) error); ok { + r1 = rf(ctx, entity, poolID, param) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // UpdateInstance provides a mock function with given fields: ctx, instanceID, param func (_m *Store) UpdateInstance(ctx context.Context, instanceID string, param params.UpdateInstanceParams) (params.Instance, error) { ret := _m.Called(ctx, instanceID, param) diff --git a/database/sql/enterprise.go b/database/sql/enterprise.go index f8665a45..c3bf5d69 100644 --- a/database/sql/enterprise.go +++ b/database/sql/enterprise.go @@ -201,16 +201,16 @@ func (s *sqlDatabase) CreateEnterprisePool(ctx context.Context, enterpriseID str return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) GetEnterprisePool(ctx context.Context, enterpriseID, poolID string) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeEnterprise, enterpriseID, poolID, "Tags", "Instances") +func (s *sqlDatabase) GetEnterprisePool(_ context.Context, enterpriseID, poolID string) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeEnterprise, enterpriseID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) DeleteEnterprisePool(ctx context.Context, enterpriseID, poolID string) error { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeEnterprise, enterpriseID, poolID) +func (s *sqlDatabase) DeleteEnterprisePool(_ context.Context, enterpriseID, poolID string) error { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeEnterprise, enterpriseID, poolID) if err != nil { return errors.Wrap(err, "looking up enterprise pool") } @@ -221,13 +221,13 @@ func (s *sqlDatabase) DeleteEnterprisePool(ctx context.Context, enterpriseID, po return nil } -func (s *sqlDatabase) UpdateEnterprisePool(ctx context.Context, enterpriseID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeEnterprise, enterpriseID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") +func (s *sqlDatabase) UpdateEnterprisePool(_ context.Context, enterpriseID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeEnterprise, enterpriseID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } - return s.updatePool(pool, param) + return s.updatePool(s.conn, pool, param) } func (s *sqlDatabase) ListEnterprisePools(ctx context.Context, enterpriseID string) ([]params.Pool, error) { diff --git a/database/sql/enterprise_test.go b/database/sql/enterprise_test.go index 86b68872..4f4a7da2 100644 --- a/database/sql/enterprise_test.go +++ b/database/sql/enterprise_test.go @@ -405,7 +405,11 @@ func (s *EnterpriseTestSuite) TestGetEnterpriseByIDDBDecryptingErr() { } func (s *EnterpriseTestSuite) TestCreateEnterprisePool() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().Nil(err) @@ -422,18 +426,25 @@ func (s *EnterpriseTestSuite) TestCreateEnterprisePool() { func (s *EnterpriseTestSuite) TestCreateEnterprisePoolMissingTags() { s.Fixtures.CreatePoolParams.Tags = []string{} - - _, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) s.Require().Equal("no tags specified", err.Error()) } func (s *EnterpriseTestSuite) TestCreateEnterprisePoolInvalidEnterpriseID() { - _, err := s.Store.CreateEnterprisePool(context.Background(), "dummy-enterprise-id", s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: "dummy-enterprise-id", + EntityType: params.GithubEntityTypeEnterprise, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching enterprise: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *EnterpriseTestSuite) TestCreateEnterprisePoolDBCreateErr() { @@ -655,9 +666,13 @@ func (s *EnterpriseTestSuite) TestCreateEnterprisePoolDBFetchPoolErr() { func (s *EnterpriseTestSuite) TestListEnterprisePools() { enterprisePools := []params.Pool{} + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Flavor = fmt.Sprintf("test-flavor-%v", i) - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } @@ -678,46 +693,66 @@ func (s *EnterpriseTestSuite) TestListEnterprisePoolsInvalidEnterpriseID() { } func (s *EnterpriseTestSuite) TestGetEnterprisePool() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } - enterprisePool, err := s.Store.GetEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, pool.ID) + enterprisePool, err := s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) s.Require().Equal(enterprisePool.ID, pool.ID) } func (s *EnterpriseTestSuite) TestGetEnterprisePoolInvalidEnterpriseID() { - _, err := s.Store.GetEnterprisePool(context.Background(), "dummy-enterprise-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-enterprise-id", + EntityType: params.GithubEntityTypeEnterprise, + } + _, err := s.Store.GetEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *EnterpriseTestSuite) TestDeleteEnterprisePool() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } - err = s.Store.DeleteEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, pool.ID) + err = s.Store.DeleteEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) - _, err = s.Store.GetEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, pool.ID) + _, err = s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolInvalidEnterpriseID() { - err := s.Store.DeleteEnterprisePool(context.Background(), "dummy-enterprise-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-enterprise-id", + EntityType: params.GithubEntityTypeEnterprise, + } + err := s.Store.DeleteEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up enterprise pool: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolDBDeleteErr() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } @@ -741,7 +776,11 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolDBDeleteErr() { } func (s *EnterpriseTestSuite) TestListEnterpriseInstances() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } @@ -769,7 +808,11 @@ func (s *EnterpriseTestSuite) TestListEnterpriseInstancesInvalidEnterpriseID() { } func (s *EnterpriseTestSuite) TestUpdateEnterprisePool() { - pool, err := s.Store.CreateEnterprisePool(context.Background(), s.Fixtures.Enterprises[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Enterprises[0].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } diff --git a/database/sql/instances.go b/database/sql/instances.go index 552fc39d..d24961da 100644 --- a/database/sql/instances.go +++ b/database/sql/instances.go @@ -48,7 +48,7 @@ func (s *sqlDatabase) unsealAndUnmarshal(data []byte, target interface{}) error return nil } -func (s *sqlDatabase) CreateInstance(ctx context.Context, poolID string, param params.CreateInstanceParams) (params.Instance, error) { +func (s *sqlDatabase) CreateInstance(_ context.Context, poolID string, param params.CreateInstanceParams) (params.Instance, error) { pool, err := s.getPoolByID(s.conn, poolID) if err != nil { return params.Instance{}, errors.Wrap(err, "fetching pool") @@ -152,7 +152,7 @@ func (s *sqlDatabase) getInstanceByName(_ context.Context, instanceName string, return instance, nil } -func (s *sqlDatabase) GetPoolInstanceByName(ctx context.Context, poolID string, instanceName string) (params.Instance, error) { +func (s *sqlDatabase) GetPoolInstanceByName(_ context.Context, poolID string, instanceName string) (params.Instance, error) { instance, err := s.getPoolInstanceByName(poolID, instanceName) if err != nil { return params.Instance{}, errors.Wrap(err, "fetching instance") @@ -170,7 +170,7 @@ func (s *sqlDatabase) GetInstanceByName(ctx context.Context, instanceName string return s.sqlToParamsInstance(instance) } -func (s *sqlDatabase) DeleteInstance(ctx context.Context, poolID string, instanceName string) error { +func (s *sqlDatabase) DeleteInstance(_ context.Context, poolID string, instanceName string) error { instance, err := s.getPoolInstanceByName(poolID, instanceName) if err != nil { return errors.Wrap(err, "deleting instance") @@ -337,7 +337,7 @@ func (s *sqlDatabase) ListAllInstances(_ context.Context) ([]params.Instance, er return ret, nil } -func (s *sqlDatabase) PoolInstanceCount(ctx context.Context, poolID string) (int64, error) { +func (s *sqlDatabase) PoolInstanceCount(_ context.Context, poolID string) (int64, error) { pool, err := s.getPoolByID(s.conn, poolID) if err != nil { return 0, errors.Wrap(err, "fetching pool") diff --git a/database/sql/instances_test.go b/database/sql/instances_test.go index 0c0eadcf..200c683b 100644 --- a/database/sql/instances_test.go +++ b/database/sql/instances_test.go @@ -92,7 +92,11 @@ func (s *InstancesTestSuite) SetupTest() { OSType: "linux", Tags: []string{"self-hosted", "amd64", "linux"}, } - pool, err := s.Store.CreateOrganizationPool(context.Background(), org.ID, createPoolParams) + entity := params.GithubEntity{ + ID: org.ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, createPoolParams) if err != nil { s.FailNow(fmt.Sprintf("failed to create org pool: %s", err)) } diff --git a/database/sql/organizations.go b/database/sql/organizations.go index 5ee28520..a2b14ae5 100644 --- a/database/sql/organizations.go +++ b/database/sql/organizations.go @@ -235,16 +235,16 @@ func (s *sqlDatabase) ListOrgPools(ctx context.Context, orgID string) ([]params. return ret, nil } -func (s *sqlDatabase) GetOrganizationPool(ctx context.Context, orgID, poolID string) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeOrganization, orgID, poolID, "Tags", "Instances") +func (s *sqlDatabase) GetOrganizationPool(_ context.Context, orgID, poolID string) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeOrganization, orgID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) DeleteOrganizationPool(ctx context.Context, orgID, poolID string) error { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeOrganization, orgID, poolID) +func (s *sqlDatabase) DeleteOrganizationPool(_ context.Context, orgID, poolID string) error { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeOrganization, orgID, poolID) if err != nil { return errors.Wrap(err, "looking up org pool") } @@ -273,13 +273,13 @@ func (s *sqlDatabase) ListOrgInstances(ctx context.Context, orgID string) ([]par return ret, nil } -func (s *sqlDatabase) UpdateOrganizationPool(ctx context.Context, orgID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeOrganization, orgID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") +func (s *sqlDatabase) UpdateOrganizationPool(_ context.Context, orgID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeOrganization, orgID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } - return s.updatePool(pool, param) + return s.updatePool(s.conn, pool, param) } func (s *sqlDatabase) getOrgByID(_ context.Context, id string, preload ...string) (Organization, error) { diff --git a/database/sql/organizations_test.go b/database/sql/organizations_test.go index 126c54ab..63b4cebd 100644 --- a/database/sql/organizations_test.go +++ b/database/sql/organizations_test.go @@ -405,7 +405,11 @@ func (s *OrgTestSuite) TestGetOrganizationByIDDBDecryptingErr() { } func (s *OrgTestSuite) TestCreateOrganizationPool() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().Nil(err) @@ -422,18 +426,25 @@ func (s *OrgTestSuite) TestCreateOrganizationPool() { func (s *OrgTestSuite) TestCreateOrganizationPoolMissingTags() { s.Fixtures.CreatePoolParams.Tags = []string{} - - _, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) s.Require().Equal("no tags specified", err.Error()) } func (s *OrgTestSuite) TestCreateOrganizationPoolInvalidOrgID() { - _, err := s.Store.CreateOrganizationPool(context.Background(), "dummy-org-id", s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: "dummy-org-id", + EntityType: params.GithubEntityTypeOrganization, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching org: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *OrgTestSuite) TestCreateOrganizationPoolDBCreateErr() { @@ -655,9 +666,13 @@ func (s *OrgTestSuite) TestCreateOrganizationPoolDBFetchPoolErr() { func (s *OrgTestSuite) TestListOrgPools() { orgPools := []params.Pool{} + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Flavor = fmt.Sprintf("test-flavor-%v", i) - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -678,46 +693,66 @@ func (s *OrgTestSuite) TestListOrgPoolsInvalidOrgID() { } func (s *OrgTestSuite) TestGetOrganizationPool() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } - orgPool, err := s.Store.GetOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, pool.ID) + orgPool, err := s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) s.Require().Equal(orgPool.ID, pool.ID) } func (s *OrgTestSuite) TestGetOrganizationPoolInvalidOrgID() { - _, err := s.Store.GetOrganizationPool(context.Background(), "dummy-org-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-org-id", + EntityType: params.GithubEntityTypeOrganization, + } + _, err := s.Store.GetEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *OrgTestSuite) TestDeleteOrganizationPool() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } - err = s.Store.DeleteOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, pool.ID) + err = s.Store.DeleteEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) - _, err = s.Store.GetOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, pool.ID) + _, err = s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } func (s *OrgTestSuite) TestDeleteOrganizationPoolInvalidOrgID() { - err := s.Store.DeleteOrganizationPool(context.Background(), "dummy-org-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-org-id", + EntityType: params.GithubEntityTypeOrganization, + } + err := s.Store.DeleteEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up org pool: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *OrgTestSuite) TestDeleteOrganizationPoolDBDeleteErr() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -741,7 +776,11 @@ func (s *OrgTestSuite) TestDeleteOrganizationPoolDBDeleteErr() { } func (s *OrgTestSuite) TestListOrgInstances() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -769,7 +808,11 @@ func (s *OrgTestSuite) TestListOrgInstancesInvalidOrgID() { } func (s *OrgTestSuite) TestUpdateOrganizationPool() { - pool, err := s.Store.CreateOrganizationPool(context.Background(), s.Fixtures.Orgs[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Orgs[0].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } diff --git a/database/sql/pools.go b/database/sql/pools.go index 5f7d0d7a..ab892eb2 100644 --- a/database/sql/pools.go +++ b/database/sql/pools.go @@ -58,7 +58,7 @@ func (s *sqlDatabase) ListAllPools(_ context.Context) ([]params.Pool, error) { return ret, nil } -func (s *sqlDatabase) GetPoolByID(ctx context.Context, poolID string) (params.Pool, error) { +func (s *sqlDatabase) GetPoolByID(_ context.Context, poolID string) (params.Pool, error) { pool, err := s.getPoolByID(s.conn, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool by ID") @@ -66,7 +66,7 @@ func (s *sqlDatabase) GetPoolByID(ctx context.Context, poolID string) (params.Po return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) DeletePoolByID(ctx context.Context, poolID string) error { +func (s *sqlDatabase) DeletePoolByID(_ context.Context, poolID string) error { pool, err := s.getPoolByID(s.conn, poolID) if err != nil { return errors.Wrap(err, "fetching pool by ID") @@ -79,7 +79,7 @@ func (s *sqlDatabase) DeletePoolByID(ctx context.Context, poolID string) error { return nil } -func (s *sqlDatabase) getEntityPool(_ context.Context, entityType params.GithubEntityType, entityID, poolID string, preload ...string) (Pool, error) { +func (s *sqlDatabase) getEntityPool(tx *gorm.DB, entityType params.GithubEntityType, entityID, poolID string, preload ...string) (Pool, error) { if entityID == "" { return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "missing entity id") } @@ -89,7 +89,7 @@ func (s *sqlDatabase) getEntityPool(_ context.Context, entityType params.GithubE return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") } - q := s.conn + q := tx if len(preload) > 0 { for _, item := range preload { q = q.Preload(item) @@ -233,7 +233,7 @@ func (s *sqlDatabase) FindPoolsMatchingAllTags(_ context.Context, entityType par return pools, nil } -func (s *sqlDatabase) CreateEntityPool(ctx context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) { +func (s *sqlDatabase) CreateEntityPool(_ context.Context, entity params.GithubEntity, param params.CreatePoolParams) (params.Pool, error) { if len(param.Tags) == 0 { return params.Pool{}, runnerErrors.NewBadRequestError("no tags specified") } @@ -258,7 +258,7 @@ func (s *sqlDatabase) CreateEntityPool(ctx context.Context, entity params.Github entityID, err := uuid.Parse(entity.ID) if err != nil { - return params.Pool{}, fmt.Errorf("parsing entity ID: %w", err) + return params.Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") } switch entity.EntityType { @@ -270,9 +270,14 @@ func (s *sqlDatabase) CreateEntityPool(ctx context.Context, entity params.Github newPool.EnterpriseID = &entityID } err = s.conn.Transaction(func(tx *gorm.DB) error { + ok, err := s.hasGithubEntity(tx, entity.EntityType, entity.ID) + if err != nil || !ok { + return errors.Wrap(err, "checking entity existence") + } + if _, err := s.getEntityPoolByUniqueFields(tx, entity, newPool.ProviderName, newPool.Image, newPool.Flavor); err != nil { if !errors.Is(err, runnerErrors.ErrNotFound) { - return fmt.Errorf("checking for existing pool: %w", err) + return errors.Wrap(err, "checking pool existence") } } else { return runnerErrors.NewConflictError("pool with the same image and flavor already exists on this provider") @@ -282,25 +287,25 @@ func (s *sqlDatabase) CreateEntityPool(ctx context.Context, entity params.Github for _, val := range param.Tags { t, err := s.getOrCreateTag(tx, val) if err != nil { - return fmt.Errorf("creating tag: %w", err) + return errors.Wrap(err, "creating tag") } tags = append(tags, t) } q := tx.Create(&newPool) if q.Error != nil { - return fmt.Errorf("creating pool: %w", q.Error) + return errors.Wrap(q.Error, "creating pool") } for i := range tags { if err := tx.Model(&newPool).Association("Tags").Append(&tags[i]); err != nil { - return fmt.Errorf("associating tags: %w", err) + return errors.Wrap(err, "associating tags") } } return nil }) if err != nil { - return params.Pool{}, fmt.Errorf("creating pool: %w", err) + return params.Pool{}, errors.Wrap(err, "creating pool") } pool, err := s.getPoolByID(s.conn, newPool.ID.String(), "Tags", "Instances", "Enterprise", "Organization", "Repository") @@ -311,22 +316,53 @@ func (s *sqlDatabase) CreateEntityPool(ctx context.Context, entity params.Github return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) GetEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) { - return params.Pool{}, nil +func (s *sqlDatabase) GetEntityPool(_ context.Context, entity params.GithubEntity, poolID string) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, entity.EntityType, entity.ID, poolID, "Tags", "Instances") + if err != nil { + return params.Pool{}, fmt.Errorf("fetching pool: %w", err) + } + return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) DeleteEntityPool(ctx context.Context, entity params.GithubEntity, poolID string) error { +func (s *sqlDatabase) DeleteEntityPool(_ context.Context, entity params.GithubEntity, poolID string) error { + entityID, err := uuid.Parse(entity.ID) + if err != nil { + return errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") + } + + poolUUID, err := uuid.Parse(poolID) + if err != nil { + return errors.Wrap(runnerErrors.ErrBadRequest, "parsing pool id") + } + var fieldName string + switch entity.EntityType { + case params.GithubEntityTypeRepository: + fieldName = entityTypeRepoName + case params.GithubEntityTypeOrganization: + fieldName = entityTypeOrgName + case params.GithubEntityTypeEnterprise: + fieldName = entityTypeEnterpriseName + default: + return fmt.Errorf("invalid entityType: %v", entity.EntityType) + } + condition := fmt.Sprintf("id = ? and %s = ?", fieldName) + if err := s.conn.Unscoped().Where(condition, poolUUID, entityID).Delete(&Pool{}).Error; err != nil { + return errors.Wrap(err, "removing pool") + } return nil } -func (s *sqlDatabase) UpdateEntityPool(ctx context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) { +func (s *sqlDatabase) UpdateEntityPool(_ context.Context, entity params.GithubEntity, poolID string, param params.UpdatePoolParams) (params.Pool, error) { + fmt.Printf("UpdateEntityPool: %v %v %v\n", entity, poolID, param) return params.Pool{}, nil } -func (s *sqlDatabase) ListEntityPools(ctx context.Context, entity params.GithubEntity) ([]params.Pool, error) { +func (s *sqlDatabase) ListEntityPools(_ context.Context, entity params.GithubEntity) ([]params.Pool, error) { + fmt.Println(entity) return nil, nil } -func (s *sqlDatabase) ListEntityInstances(ctx context.Context, entity params.GithubEntity) ([]params.Instance, error) { +func (s *sqlDatabase) ListEntityInstances(_ context.Context, entity params.GithubEntity) ([]params.Instance, error) { + fmt.Println(entity) return nil, nil } diff --git a/database/sql/pools_test.go b/database/sql/pools_test.go index 33fe8725..aac01f99 100644 --- a/database/sql/pools_test.go +++ b/database/sql/pools_test.go @@ -66,12 +66,16 @@ func (s *PoolsTestSuite) SetupTest() { s.FailNow(fmt.Sprintf("failed to create org: %s", err)) } + entity := params.GithubEntity{ + ID: org.ID, + EntityType: params.GithubEntityTypeOrganization, + } // create some pool objects in the database, for testing purposes orgPools := []params.Pool{} for i := 1; i <= 3; i++ { - pool, err := db.CreateOrganizationPool( + pool, err := db.CreateEntityPool( context.Background(), - org.ID, + entity, params.CreatePoolParams{ ProviderName: "test-provider", MaxRunners: 4, diff --git a/database/sql/repositories.go b/database/sql/repositories.go index 0da0e794..936b796c 100644 --- a/database/sql/repositories.go +++ b/database/sql/repositories.go @@ -235,16 +235,16 @@ func (s *sqlDatabase) ListRepoPools(ctx context.Context, repoID string) ([]param return ret, nil } -func (s *sqlDatabase) GetRepositoryPool(ctx context.Context, repoID, poolID string) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeRepository, repoID, poolID, "Tags", "Instances") +func (s *sqlDatabase) GetRepositoryPool(_ context.Context, repoID, poolID string) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeRepository, repoID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } return s.sqlToCommonPool(pool) } -func (s *sqlDatabase) DeleteRepositoryPool(ctx context.Context, repoID, poolID string) error { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeRepository, repoID, poolID) +func (s *sqlDatabase) DeleteRepositoryPool(_ context.Context, repoID, poolID string) error { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeRepository, repoID, poolID) if err != nil { return errors.Wrap(err, "looking up repo pool") } @@ -274,13 +274,13 @@ func (s *sqlDatabase) ListRepoInstances(ctx context.Context, repoID string) ([]p return ret, nil } -func (s *sqlDatabase) UpdateRepositoryPool(ctx context.Context, repoID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getEntityPool(ctx, params.GithubEntityTypeRepository, repoID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") +func (s *sqlDatabase) UpdateRepositoryPool(_ context.Context, repoID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { + pool, err := s.getEntityPool(s.conn, params.GithubEntityTypeRepository, repoID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } - return s.updatePool(pool, param) + return s.updatePool(s.conn, pool, param) } func (s *sqlDatabase) getRepo(_ context.Context, owner, name string) (Repository, error) { diff --git a/database/sql/repositories_test.go b/database/sql/repositories_test.go index 5a5396b8..ab1f9da5 100644 --- a/database/sql/repositories_test.go +++ b/database/sql/repositories_test.go @@ -443,7 +443,11 @@ func (s *RepoTestSuite) TestGetRepositoryByIDDBDecryptingErr() { } func (s *RepoTestSuite) TestCreateRepositoryPool() { - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().Nil(err) repo, err := s.Store.GetRepositoryByID(context.Background(), s.Fixtures.Repos[0].ID) @@ -459,18 +463,25 @@ func (s *RepoTestSuite) TestCreateRepositoryPool() { func (s *RepoTestSuite) TestCreateRepositoryPoolMissingTags() { s.Fixtures.CreatePoolParams.Tags = []string{} - - _, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) s.Require().Equal("no tags specified", err.Error()) } func (s *RepoTestSuite) TestCreateRepositoryPoolInvalidRepoID() { - _, err := s.Store.CreateRepositoryPool(context.Background(), "dummy-repo-id", s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: "dummy-repo-id", + EntityType: params.GithubEntityTypeRepository, + } + _, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching repo: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *RepoTestSuite) TestCreateRepositoryPoolDBCreateErr() { @@ -691,10 +702,14 @@ func (s *RepoTestSuite) TestCreateRepositoryPoolDBFetchPoolErr() { } func (s *RepoTestSuite) TestListRepoPools() { + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } repoPools := []params.Pool{} for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Flavor = fmt.Sprintf("test-flavor-%d", i) - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } @@ -715,46 +730,66 @@ func (s *RepoTestSuite) TestListRepoPoolsInvalidRepoID() { } func (s *RepoTestSuite) TestGetRepositoryPool() { - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } - repoPool, err := s.Store.GetRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, pool.ID) + repoPool, err := s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) s.Require().Equal(repoPool.ID, pool.ID) } func (s *RepoTestSuite) TestGetRepositoryPoolInvalidRepoID() { - _, err := s.Store.GetRepositoryPool(context.Background(), "dummy-repo-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-repo-id", + EntityType: params.GithubEntityTypeRepository, + } + _, err := s.Store.GetEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPool() { - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } - err = s.Store.DeleteRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, pool.ID) + err = s.Store.DeleteEntityPool(context.Background(), entity, pool.ID) s.Require().Nil(err) - _, err = s.Store.GetOrganizationPool(context.Background(), s.Fixtures.Repos[0].ID, pool.ID) + _, err = s.Store.GetEntityPool(context.Background(), entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPoolInvalidRepoID() { - err := s.Store.DeleteRepositoryPool(context.Background(), "dummy-repo-id", "dummy-pool-id") + entity := params.GithubEntity{ + ID: "dummy-repo-id", + EntityType: params.GithubEntityTypeRepository, + } + err := s.Store.DeleteEntityPool(context.Background(), entity, "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up repo pool: parsing id: invalid request", err.Error()) + s.Require().Equal("parsing id: invalid request", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPoolDBDeleteErr() { - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } @@ -778,7 +813,11 @@ func (s *RepoTestSuite) TestDeleteRepositoryPoolDBDeleteErr() { } func (s *RepoTestSuite) TestListRepoInstances() { - pool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } @@ -806,7 +845,11 @@ func (s *RepoTestSuite) TestListRepoInstancesInvalidRepoID() { } func (s *RepoTestSuite) TestUpdateRepositoryPool() { - repoPool, err := s.Store.CreateRepositoryPool(context.Background(), s.Fixtures.Repos[0].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.Repos[0].ID, + EntityType: params.GithubEntityTypeRepository, + } + repoPool, err := s.Store.CreateEntityPool(context.Background(), entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } diff --git a/database/sql/util.go b/database/sql/util.go index f0bcc867..2a41050c 100644 --- a/database/sql/util.go +++ b/database/sql/util.go @@ -297,7 +297,7 @@ func (s *sqlDatabase) getOrCreateTag(tx *gorm.DB, tagName string) (Tag, error) { return newTag, nil } -func (s *sqlDatabase) updatePool(pool Pool, param params.UpdatePoolParams) (params.Pool, error) { +func (s *sqlDatabase) updatePool(tx *gorm.DB, pool Pool, param params.UpdatePoolParams) (params.Pool, error) { if param.Enabled != nil && pool.Enabled != *param.Enabled { pool.Enabled = *param.Enabled } @@ -346,21 +346,21 @@ func (s *sqlDatabase) updatePool(pool Pool, param params.UpdatePoolParams) (para pool.Priority = *param.Priority } - if q := s.conn.Save(&pool); q.Error != nil { + if q := tx.Save(&pool); q.Error != nil { return params.Pool{}, errors.Wrap(q.Error, "saving database entry") } tags := []Tag{} if param.Tags != nil && len(param.Tags) > 0 { for _, val := range param.Tags { - t, err := s.getOrCreateTag(s.conn, val) + t, err := s.getOrCreateTag(tx, val) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching tag") } tags = append(tags, t) } - if err := s.conn.Model(&pool).Association("Tags").Replace(&tags); err != nil { + if err := tx.Model(&pool).Association("Tags").Replace(&tags); err != nil { return params.Pool{}, errors.Wrap(err, "replacing tags") } } @@ -391,3 +391,30 @@ func (s *sqlDatabase) getPoolByID(tx *gorm.DB, poolID string, preload ...string) } return pool, nil } + +func (s *sqlDatabase) hasGithubEntity(tx *gorm.DB, entityType params.GithubEntityType, entityID string) (bool, error) { + u, err := uuid.Parse(entityID) + if err != nil { + return false, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") + } + var q *gorm.DB + switch entityType { + case params.GithubEntityTypeRepository: + q = tx.Model(&Repository{}).Where("id = ?", u) + case params.GithubEntityTypeOrganization: + q = tx.Model(&Organization{}).Where("id = ?", u) + case params.GithubEntityTypeEnterprise: + q = tx.Model(&Enterprise{}).Where("id = ?", u) + default: + return false, errors.Wrap(runnerErrors.ErrBadRequest, "invalid entity type") + } + + var entity interface{} + if err := q.First(entity).Error; err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return false, errors.Wrap(runnerErrors.ErrNotFound, "entity not found") + } + return false, errors.Wrap(err, "fetching entity from database") + } + return true, nil +} diff --git a/runner/enterprises.go b/runner/enterprises.go index ae1e2fc8..7d6e5b8e 100644 --- a/runner/enterprises.go +++ b/runner/enterprises.go @@ -193,14 +193,9 @@ func (r *Runner) CreateEnterprisePool(ctx context.Context, enterpriseID string, return params.Pool{}, runnerErrors.ErrUnauthorized } - _, err := r.store.GetEnterpriseByID(ctx, enterpriseID) - if err != nil { - return params.Pool{}, errors.Wrap(err, "fetching enterprise") - } - createPoolParams, err := r.appendTagsToCreatePoolParams(param) if err != nil { - return params.Pool{}, errors.Wrap(err, "fetching pool params") + return params.Pool{}, fmt.Errorf("failed to append tags to create pool params: %w", err) } if param.RunnerBootstrapTimeout == 0 { @@ -214,7 +209,7 @@ func (r *Runner) CreateEnterprisePool(ctx context.Context, enterpriseID string, pool, err := r.store.CreateEntityPool(ctx, entity, createPoolParams) if err != nil { - return params.Pool{}, errors.Wrap(err, "creating pool") + return params.Pool{}, fmt.Errorf("failed to create enterprise pool: %w", err) } return pool, nil @@ -224,8 +219,11 @@ func (r *Runner) GetEnterprisePoolByID(ctx context.Context, enterpriseID, poolID if !auth.IsAdmin(ctx) { return params.Pool{}, runnerErrors.ErrUnauthorized } - - pool, err := r.store.GetEnterprisePool(ctx, enterpriseID, poolID) + entity := params.GithubEntity{ + ID: enterpriseID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -237,29 +235,27 @@ func (r *Runner) DeleteEnterprisePool(ctx context.Context, enterpriseID, poolID return runnerErrors.ErrUnauthorized } - // nolint:golangci-lint,godox - // TODO: dedup instance count verification - pool, err := r.store.GetEnterprisePool(ctx, enterpriseID, poolID) + entity := params.GithubEntity{ + ID: enterpriseID, + EntityType: params.GithubEntityTypeEnterprise, + } + + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return errors.Wrap(err, "fetching pool") } - instances, err := r.store.ListPoolInstances(ctx, pool.ID) - if err != nil { - return errors.Wrap(err, "fetching instances") - } - // nolint:golangci-lint,godox // TODO: implement a count function - if len(instances) > 0 { + if len(pool.Instances) > 0 { runnerIDs := []string{} - for _, run := range instances { + for _, run := range pool.Instances { runnerIDs = append(runnerIDs, run.ID) } return runnerErrors.NewBadRequestError("pool has runners: %s", strings.Join(runnerIDs, ", ")) } - if err := r.store.DeleteEnterprisePool(ctx, enterpriseID, poolID); err != nil { + if err := r.store.DeleteEntityPool(ctx, entity, poolID); err != nil { return errors.Wrap(err, "deleting pool") } return nil @@ -282,7 +278,11 @@ func (r *Runner) UpdateEnterprisePool(ctx context.Context, enterpriseID, poolID return params.Pool{}, runnerErrors.ErrUnauthorized } - pool, err := r.store.GetEnterprisePool(ctx, enterpriseID, poolID) + entity := params.GithubEntity{ + ID: enterpriseID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } diff --git a/runner/enterprises_test.go b/runner/enterprises_test.go index 311e743a..dc81da5e 100644 --- a/runner/enterprises_test.go +++ b/runner/enterprises_test.go @@ -272,7 +272,11 @@ func (s *EnterpriseTestSuite) TestDeleteEnterpriseErrUnauthorized() { } func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolDefinedFailed() { - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create store enterprises pool: %v", err)) } @@ -340,8 +344,6 @@ func (s *EnterpriseTestSuite) TestUpdateEnterpriseCreateEnterprisePoolMgrFailed( } func (s *EnterpriseTestSuite) TestCreateEnterprisePool() { - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, nil) - pool, err := s.Runner.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) @@ -365,30 +367,21 @@ func (s *EnterpriseTestSuite) TestCreateEnterprisePoolErrUnauthorized() { s.Require().Equal(runnerErrors.ErrUnauthorized, err) } -func (s *EnterpriseTestSuite) TestCreateEnterprisePoolErrNotFound() { - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, runnerErrors.ErrNotFound) - - _, err := s.Runner.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) - - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) - s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(runnerErrors.ErrNotFound, err) -} - func (s *EnterpriseTestSuite) TestCreateEnterprisePoolFetchPoolParamsFailed() { s.Fixtures.CreatePoolParams.ProviderName = notExistingProviderName - - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, nil) - _, err := s.Runner.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Regexp("fetching pool params: no such provider", err.Error()) + s.Require().Regexp("failed to append tags to create pool params: no such provider not-existent-provider-name", err.Error()) } func (s *EnterpriseTestSuite) TestGetEnterprisePoolByID() { - enterprisePool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + enterprisePool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %s", err)) } @@ -406,7 +399,11 @@ func (s *EnterpriseTestSuite) TestGetEnterprisePoolByIDErrUnauthorized() { } func (s *EnterpriseTestSuite) TestDeleteEnterprisePool() { - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %s", err)) } @@ -415,7 +412,7 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePool() { s.Require().Nil(err) - _, err = s.Fixtures.Store.GetEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, pool.ID) + _, err = s.Fixtures.Store.GetEntityPool(s.Fixtures.AdminContext, entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } @@ -426,7 +423,11 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolErrUnauthorized() { } func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolRunnersFailed() { - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } @@ -441,10 +442,14 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolRunnersFailed() { } func (s *EnterpriseTestSuite) TestListEnterprisePools() { + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } enterprisePools := []params.Pool{} for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Image = fmt.Sprintf("test-enterprise-%v", i) - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -464,7 +469,11 @@ func (s *EnterpriseTestSuite) TestListOrgPoolsErrUnauthorized() { } func (s *EnterpriseTestSuite) TestUpdateEnterprisePool() { - enterprisePool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + enterprisePool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %s", err)) } @@ -483,7 +492,11 @@ func (s *EnterpriseTestSuite) TestUpdateEnterprisePoolErrUnauthorized() { } func (s *EnterpriseTestSuite) TestUpdateEnterprisePoolMinIdleGreaterThanMax() { - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %s", err)) } @@ -498,7 +511,11 @@ func (s *EnterpriseTestSuite) TestUpdateEnterprisePoolMinIdleGreaterThanMax() { } func (s *EnterpriseTestSuite) TestListEnterpriseInstances() { - pool, err := s.Fixtures.Store.CreateEnterprisePool(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, + EntityType: params.GithubEntityTypeEnterprise, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } diff --git a/runner/organizations.go b/runner/organizations.go index 482bd55d..258753f0 100644 --- a/runner/organizations.go +++ b/runner/organizations.go @@ -222,11 +222,6 @@ func (r *Runner) CreateOrgPool(ctx context.Context, orgID string, param params.C return params.Pool{}, runnerErrors.ErrUnauthorized } - _, err := r.store.GetOrganizationByID(ctx, orgID) - if err != nil { - return params.Pool{}, errors.Wrap(err, "fetching org") - } - createPoolParams, err := r.appendTagsToCreatePoolParams(param) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool params") @@ -254,10 +249,16 @@ func (r *Runner) GetOrgPoolByID(ctx context.Context, orgID, poolID string) (para return params.Pool{}, runnerErrors.ErrUnauthorized } - pool, err := r.store.GetOrganizationPool(ctx, orgID, poolID) + entity := params.GithubEntity{ + ID: orgID, + EntityType: params.GithubEntityTypeOrganization, + } + + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } + return pool, nil } @@ -266,29 +267,30 @@ func (r *Runner) DeleteOrgPool(ctx context.Context, orgID, poolID string) error return runnerErrors.ErrUnauthorized } - // nolint:golangci-lint,godox - // TODO: dedup instance count verification - pool, err := r.store.GetOrganizationPool(ctx, orgID, poolID) - if err != nil { - return errors.Wrap(err, "fetching pool") + entity := params.GithubEntity{ + ID: orgID, + EntityType: params.GithubEntityTypeOrganization, } - instances, err := r.store.ListPoolInstances(ctx, pool.ID) + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { - return errors.Wrap(err, "fetching instances") + if !errors.Is(err, runnerErrors.ErrNotFound) { + return errors.Wrap(err, "fetching pool") + } + return nil } // nolint:golangci-lint,godox // TODO: implement a count function - if len(instances) > 0 { + if len(pool.Instances) > 0 { runnerIDs := []string{} - for _, run := range instances { + for _, run := range pool.Instances { runnerIDs = append(runnerIDs, run.ID) } return runnerErrors.NewBadRequestError("pool has runners: %s", strings.Join(runnerIDs, ", ")) } - if err := r.store.DeleteOrganizationPool(ctx, orgID, poolID); err != nil { + if err := r.store.DeleteEntityPool(ctx, entity, poolID); err != nil { return errors.Wrap(err, "deleting pool") } return nil @@ -311,7 +313,12 @@ func (r *Runner) UpdateOrgPool(ctx context.Context, orgID, poolID string, param return params.Pool{}, runnerErrors.ErrUnauthorized } - pool, err := r.store.GetOrganizationPool(ctx, orgID, poolID) + entity := params.GithubEntity{ + ID: orgID, + EntityType: params.GithubEntityTypeOrganization, + } + + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } diff --git a/runner/organizations_test.go b/runner/organizations_test.go index 7ebfcff8..d0113756 100644 --- a/runner/organizations_test.go +++ b/runner/organizations_test.go @@ -285,7 +285,11 @@ func (s *OrgTestSuite) TestDeleteOrganizationErrUnauthorized() { } func (s *OrgTestSuite) TestDeleteOrganizationPoolDefinedFailed() { - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create store organizations pool: %v", err)) } @@ -365,8 +369,6 @@ func (s *OrgTestSuite) TestUpdateOrganizationCreateOrgPoolMgrFailed() { } func (s *OrgTestSuite) TestCreateOrgPool() { - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, nil) - pool, err := s.Runner.CreateOrgPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) @@ -390,21 +392,8 @@ func (s *OrgTestSuite) TestCreateOrgPoolErrUnauthorized() { s.Require().Equal(runnerErrors.ErrUnauthorized, err) } -func (s *OrgTestSuite) TestCreateOrgPoolErrNotFound() { - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, runnerErrors.ErrNotFound) - - _, err := s.Runner.CreateOrgPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) - - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) - s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(runnerErrors.ErrNotFound, err) -} - func (s *OrgTestSuite) TestCreateOrgPoolFetchPoolParamsFailed() { s.Fixtures.CreatePoolParams.ProviderName = notExistingProviderName - - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, nil) - _, err := s.Runner.CreateOrgPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) @@ -413,7 +402,11 @@ func (s *OrgTestSuite) TestCreateOrgPoolFetchPoolParamsFailed() { } func (s *OrgTestSuite) TestGetOrgPoolByID() { - orgPool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + orgPool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %s", err)) } @@ -431,7 +424,11 @@ func (s *OrgTestSuite) TestGetOrgPoolByIDErrUnauthorized() { } func (s *OrgTestSuite) TestDeleteOrgPool() { - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %s", err)) } @@ -440,7 +437,7 @@ func (s *OrgTestSuite) TestDeleteOrgPool() { s.Require().Nil(err) - _, err = s.Fixtures.Store.GetOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, pool.ID) + _, err = s.Fixtures.Store.GetEntityPool(s.Fixtures.AdminContext, entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } @@ -451,7 +448,11 @@ func (s *OrgTestSuite) TestDeleteOrgPoolErrUnauthorized() { } func (s *OrgTestSuite) TestDeleteOrgPoolRunnersFailed() { - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -466,10 +467,14 @@ func (s *OrgTestSuite) TestDeleteOrgPoolRunnersFailed() { } func (s *OrgTestSuite) TestListOrgPools() { + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } orgPools := []params.Pool{} for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Image = fmt.Sprintf("test-org-%v", i) - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } @@ -489,7 +494,11 @@ func (s *OrgTestSuite) TestListOrgPoolsErrUnauthorized() { } func (s *OrgTestSuite) TestUpdateOrgPool() { - orgPool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + orgPool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %s", err)) } @@ -508,7 +517,11 @@ func (s *OrgTestSuite) TestUpdateOrgPoolErrUnauthorized() { } func (s *OrgTestSuite) TestUpdateOrgPoolMinIdleGreaterThanMax() { - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %s", err)) } @@ -523,7 +536,11 @@ func (s *OrgTestSuite) TestUpdateOrgPoolMinIdleGreaterThanMax() { } func (s *OrgTestSuite) TestListOrgInstances() { - pool, err := s.Fixtures.Store.CreateOrganizationPool(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreOrgs["test-org-1"].ID, + EntityType: params.GithubEntityTypeOrganization, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } diff --git a/runner/pool/pool.go b/runner/pool/pool.go index 2226fa13..5291be6b 100644 --- a/runner/pool/pool.go +++ b/runner/pool/pool.go @@ -2198,16 +2198,7 @@ func (r *basePoolManager) ListPools() ([]params.Pool, error) { } func (r *basePoolManager) GetPoolByID(poolID string) (params.Pool, error) { - switch r.entity.EntityType { - case params.GithubEntityTypeRepository: - return r.store.GetRepositoryPool(r.ctx, r.entity.ID, poolID) - case params.GithubEntityTypeOrganization: - return r.store.GetOrganizationPool(r.ctx, r.entity.ID, poolID) - case params.GithubEntityTypeEnterprise: - return r.store.GetEnterprisePool(r.ctx, r.entity.ID, poolID) - default: - return params.Pool{}, fmt.Errorf("unknown entity type: %s", r.entity.EntityType) - } + return r.store.GetEntityPool(r.ctx, r.entity, poolID) } func (r *basePoolManager) GetWebhookInfo(ctx context.Context) (params.HookInfo, error) { diff --git a/runner/pools_test.go b/runner/pools_test.go index 59d6ff27..e2b269a0 100644 --- a/runner/pools_test.go +++ b/runner/pools_test.go @@ -64,11 +64,15 @@ func (s *PoolTestSuite) SetupTest() { } // create some pool objects in the database, for testing purposes + entity := params.GithubEntity{ + ID: org.ID, + EntityType: params.GithubEntityTypeOrganization, + } orgPools := []params.Pool{} for i := 1; i <= 3; i++ { - pool, err := db.CreateOrganizationPool( + pool, err := db.CreateEntityPool( context.Background(), - org.ID, + entity, params.CreatePoolParams{ ProviderName: "test-provider", MaxRunners: 4, diff --git a/runner/repositories.go b/runner/repositories.go index b8b25c06..68ef38f5 100644 --- a/runner/repositories.go +++ b/runner/repositories.go @@ -221,14 +221,9 @@ func (r *Runner) CreateRepoPool(ctx context.Context, repoID string, param params return params.Pool{}, runnerErrors.ErrUnauthorized } - _, err := r.store.GetRepositoryByID(ctx, repoID) - if err != nil { - return params.Pool{}, errors.Wrap(err, "fetching repo") - } - createPoolParams, err := r.appendTagsToCreatePoolParams(param) if err != nil { - return params.Pool{}, errors.Wrap(err, "fetching pool params") + return params.Pool{}, fmt.Errorf("failed to append tags to create pool params: %w", err) } if createPoolParams.RunnerBootstrapTimeout == 0 { @@ -242,7 +237,7 @@ func (r *Runner) CreateRepoPool(ctx context.Context, repoID string, param params pool, err := r.store.CreateEntityPool(ctx, entity, createPoolParams) if err != nil { - return params.Pool{}, errors.Wrap(err, "creating pool") + return params.Pool{}, fmt.Errorf("failed to create pool: %w", err) } return pool, nil @@ -253,10 +248,16 @@ func (r *Runner) GetRepoPoolByID(ctx context.Context, repoID, poolID string) (pa return params.Pool{}, runnerErrors.ErrUnauthorized } - pool, err := r.store.GetRepositoryPool(ctx, repoID, poolID) + entity := params.GithubEntity{ + ID: repoID, + EntityType: params.GithubEntityTypeRepository, + } + + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } + return pool, nil } @@ -265,27 +266,26 @@ func (r *Runner) DeleteRepoPool(ctx context.Context, repoID, poolID string) erro return runnerErrors.ErrUnauthorized } - pool, err := r.store.GetRepositoryPool(ctx, repoID, poolID) + entity := params.GithubEntity{ + ID: repoID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return errors.Wrap(err, "fetching pool") } - instances, err := r.store.ListPoolInstances(ctx, pool.ID) - if err != nil { - return errors.Wrap(err, "fetching instances") - } - // nolint:golangci-lint,godox // TODO: implement a count function - if len(instances) > 0 { + if len(pool.Instances) > 0 { runnerIDs := []string{} - for _, run := range instances { + for _, run := range pool.Instances { runnerIDs = append(runnerIDs, run.ID) } return runnerErrors.NewBadRequestError("pool has runners: %s", strings.Join(runnerIDs, ", ")) } - if err := r.store.DeleteRepositoryPool(ctx, repoID, poolID); err != nil { + if err := r.store.DeleteEntityPool(ctx, entity, poolID); err != nil { return errors.Wrap(err, "deleting pool") } return nil @@ -320,7 +320,11 @@ func (r *Runner) UpdateRepoPool(ctx context.Context, repoID, poolID string, para return params.Pool{}, runnerErrors.ErrUnauthorized } - pool, err := r.store.GetRepositoryPool(ctx, repoID, poolID) + entity := params.GithubEntity{ + ID: repoID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := r.store.GetEntityPool(ctx, entity, poolID) if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } diff --git a/runner/repositories_test.go b/runner/repositories_test.go index 8a1e8d9c..20814a86 100644 --- a/runner/repositories_test.go +++ b/runner/repositories_test.go @@ -295,7 +295,11 @@ func (s *RepoTestSuite) TestDeleteRepositoryErrUnauthorized() { } func (s *RepoTestSuite) TestDeleteRepositoryPoolDefinedFailed() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create store repositories pool: %v", err)) } @@ -376,8 +380,6 @@ func (s *RepoTestSuite) TestUpdateRepositoryCreateRepoPoolMgrFailed() { } func (s *RepoTestSuite) TestCreateRepoPool() { - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, nil) - pool, err := s.Runner.CreateRepoPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) @@ -401,30 +403,21 @@ func (s *RepoTestSuite) TestCreateRepoPoolErrUnauthorized() { s.Require().Equal(runnerErrors.ErrUnauthorized, err) } -func (s *RepoTestSuite) TestCreateRepoPoolErrNotFound() { - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) - - _, err := s.Runner.CreateRepoPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) - - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) - s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(runnerErrors.ErrNotFound, err) -} - func (s *RepoTestSuite) TestCreateRepoPoolFetchPoolParamsFailed() { s.Fixtures.CreatePoolParams.ProviderName = notExistingProviderName - - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, nil) - _, err := s.Runner.CreateRepoPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Regexp("fetching pool params: no such provider", err.Error()) + s.Require().Regexp("failed to append tags to create pool params: no such provider not-existent-provider-name", err.Error()) } func (s *RepoTestSuite) TestGetRepoPoolByID() { - repoPool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + repoPool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %s", err)) } @@ -442,7 +435,11 @@ func (s *RepoTestSuite) TestGetRepoPoolByIDErrUnauthorized() { } func (s *RepoTestSuite) TestDeleteRepoPool() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %s", err)) } @@ -451,7 +448,7 @@ func (s *RepoTestSuite) TestDeleteRepoPool() { s.Require().Nil(err) - _, err = s.Fixtures.Store.GetRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, pool.ID) + _, err = s.Fixtures.Store.GetEntityPool(s.Fixtures.AdminContext, entity, pool.ID) s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } @@ -462,7 +459,11 @@ func (s *RepoTestSuite) TestDeleteRepoPoolErrUnauthorized() { } func (s *RepoTestSuite) TestDeleteRepoPoolRunnersFailed() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %s", err)) } @@ -477,10 +478,14 @@ func (s *RepoTestSuite) TestDeleteRepoPoolRunnersFailed() { } func (s *RepoTestSuite) TestListRepoPools() { + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } repoPools := []params.Pool{} for i := 1; i <= 2; i++ { s.Fixtures.CreatePoolParams.Image = fmt.Sprintf("test-repo-%v", i) - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } @@ -500,7 +505,11 @@ func (s *RepoTestSuite) TestListRepoPoolsErrUnauthorized() { } func (s *RepoTestSuite) TestListPoolInstances() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } @@ -527,7 +536,11 @@ func (s *RepoTestSuite) TestListPoolInstancesErrUnauthorized() { } func (s *RepoTestSuite) TestUpdateRepoPool() { - repoPool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + repoPool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create store repositories pool: %v", err)) } @@ -546,7 +559,11 @@ func (s *RepoTestSuite) TestUpdateRepoPoolErrUnauthorized() { } func (s *RepoTestSuite) TestUpdateRepoPoolMinIdleGreaterThanMax() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %s", err)) } @@ -561,7 +578,11 @@ func (s *RepoTestSuite) TestUpdateRepoPoolMinIdleGreaterThanMax() { } func (s *RepoTestSuite) TestListRepoInstances() { - pool, err := s.Fixtures.Store.CreateRepositoryPool(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.CreatePoolParams) + entity := params.GithubEntity{ + ID: s.Fixtures.StoreRepos["test-repo-1"].ID, + EntityType: params.GithubEntityTypeRepository, + } + pool, err := s.Fixtures.Store.CreateEntityPool(s.Fixtures.AdminContext, entity, s.Fixtures.CreatePoolParams) if err != nil { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } diff --git a/runner/runner.go b/runner/runner.go index 7eab27f9..a29fda0c 100644 --- a/runner/runner.go +++ b/runner/runner.go @@ -785,7 +785,8 @@ func (r *Runner) DispatchWorkflowJob(hookTargetType, signature string, jobData [ func (r *Runner) appendTagsToCreatePoolParams(param params.CreatePoolParams) (params.CreatePoolParams, error) { if err := param.Validate(); err != nil { - return params.CreatePoolParams{}, errors.Wrapf(runnerErrors.ErrBadRequest, "validating params: %s", err) + return params.CreatePoolParams{}, fmt.Errorf("failed to validate params (%q): %w", err, runnerErrors.ErrBadRequest) + // errors.Wrapf(runnerErrors.ErrBadRequest, "validating params: %s", err) } if !IsSupportedOSType(param.OSType) { @@ -803,7 +804,7 @@ func (r *Runner) appendTagsToCreatePoolParams(param params.CreatePoolParams) (pa newTags, err := r.processTags(string(param.OSArch), param.OSType, param.Tags) if err != nil { - return params.CreatePoolParams{}, errors.Wrap(err, "processing tags") + return params.CreatePoolParams{}, fmt.Errorf("failed to process tags: %w", err) } param.Tags = newTags