DevFW-CICD/garm
15
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

Fix tests

Browse source 
Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>
This commit is contained in:
Gabriel Adrian Samfira 2024-03-28 18:23:49 +00:00
parent 0152b21529
commit 9384e37bb1
22 changed files with 652 additions and 396 deletions
Download patch file Download diff file Expand all files Collapse all files

38
database/common/common.go
View file

@ -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

258
database/common/mocks/Store.go
View file

@ -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)

14
database/sql/enterprise.go
View file

@ -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) {

77
database/sql/enterprise_test.go
View file

@ -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))
}

8
database/sql/instances.go
View file

@ -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")

6
database/sql/instances_test.go
View file

@ -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))
}

14
database/sql/organizations.go
View file

@ -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) {

77
database/sql/organizations_test.go
View file

@ -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))
}

70
database/sql/pools.go
View file

@ -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
}

8
database/sql/pools_test.go
View file

@ -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,

14
database/sql/repositories.go
View file

@ -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) {

77
database/sql/repositories_test.go
View file

@ -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))
}

35
database/sql/util.go
View file

@ -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
}

42
runner/enterprises.go
View file

@ -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")
}

67
runner/enterprises_test.go
View file

@ -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))
}

41
runner/organizations.go
View file

@ -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")
}

65
runner/organizations_test.go
View file

@ -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))
}

11
runner/pool/pool.go
View file

@ -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) {

8
runner/pools_test.go
View file

@ -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,

40
runner/repositories.go
View file

@ -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")
}

73
runner/repositories_test.go
View file

@ -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))
}

5
runner/runner.go
View file

@ -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