github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/db/db_suite_test.go (about)

     1  package db_test
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  	"time"
     7  
     8  	"code.cloudfoundry.org/lager/lagertest"
     9  	sq "github.com/Masterminds/squirrel"
    10  
    11  	. "github.com/onsi/ginkgo"
    12  	. "github.com/onsi/gomega"
    13  
    14  	"github.com/pf-qiu/concourse/v6/atc"
    15  	"github.com/pf-qiu/concourse/v6/atc/creds/credsfakes"
    16  	"github.com/pf-qiu/concourse/v6/atc/db"
    17  	"github.com/pf-qiu/concourse/v6/atc/db/dbfakes"
    18  	"github.com/pf-qiu/concourse/v6/atc/db/dbtest"
    19  	"github.com/pf-qiu/concourse/v6/atc/db/lock"
    20  	"github.com/pf-qiu/concourse/v6/atc/metric"
    21  	"github.com/pf-qiu/concourse/v6/atc/postgresrunner"
    22  	"github.com/tedsuo/ifrit"
    23  )
    24  
    25  func TestDB(t *testing.T) {
    26  	RegisterFailHandler(Fail)
    27  	RunSpecs(t, "DB Suite")
    28  }
    29  
    30  var (
    31  	postgresRunner postgresrunner.Runner
    32  	dbProcess      ifrit.Process
    33  
    34  	dbConn                              db.Conn
    35  	fakeSecrets                         *credsfakes.FakeSecrets
    36  	fakeVarSourcePool                   *credsfakes.FakeVarSourcePool
    37  	componentFactory                    db.ComponentFactory
    38  	buildFactory                        db.BuildFactory
    39  	volumeRepository                    db.VolumeRepository
    40  	containerRepository                 db.ContainerRepository
    41  	teamFactory                         db.TeamFactory
    42  	workerFactory                       db.WorkerFactory
    43  	workerLifecycle                     db.WorkerLifecycle
    44  	resourceConfigCheckSessionLifecycle db.ResourceConfigCheckSessionLifecycle
    45  	resourceConfigFactory               db.ResourceConfigFactory
    46  	resourceCacheFactory                db.ResourceCacheFactory
    47  	taskCacheFactory                    db.TaskCacheFactory
    48  	checkFactory                        db.CheckFactory
    49  	workerBaseResourceTypeFactory       db.WorkerBaseResourceTypeFactory
    50  	workerTaskCacheFactory              db.WorkerTaskCacheFactory
    51  	userFactory                         db.UserFactory
    52  	dbWall                              db.Wall
    53  	fakeClock                           dbfakes.FakeClock
    54  
    55  	builder dbtest.Builder
    56  
    57  	defaultWorkerResourceType atc.WorkerResourceType
    58  	uniqueWorkerResourceType  atc.WorkerResourceType
    59  	defaultTeam               db.Team
    60  	defaultWorkerPayload      atc.Worker
    61  	defaultWorker             db.Worker
    62  	otherWorker               db.Worker
    63  	otherWorkerPayload        atc.Worker
    64  	defaultResourceType       db.ResourceType
    65  	defaultResource           db.Resource
    66  	defaultPipelineConfig     atc.Config
    67  	defaultPipeline           db.Pipeline
    68  	defaultPipelineRef        atc.PipelineRef
    69  	defaultJob                db.Job
    70  	logger                    *lagertest.TestLogger
    71  	lockFactory               lock.LockFactory
    72  
    73  	defaultCheckInterval        = time.Minute
    74  	defaultWebhookCheckInterval = time.Hour
    75  	defaultCheckTimeout         = 5 * time.Minute
    76  
    77  	fullMetadata = db.ContainerMetadata{
    78  		Type: db.ContainerTypeTask,
    79  
    80  		StepName: "some-step-name",
    81  		Attempt:  "1.2.3",
    82  
    83  		PipelineID: 123,
    84  		JobID:      456,
    85  		BuildID:    789,
    86  
    87  		PipelineName: "some-pipeline",
    88  		JobName:      "some-job",
    89  		BuildName:    "some-build",
    90  
    91  		WorkingDirectory: "/some/work/dir",
    92  		User:             "some-user",
    93  	}
    94  
    95  	psql = sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
    96  )
    97  
    98  var _ = BeforeSuite(func() {
    99  	postgresRunner = postgresrunner.Runner{
   100  		Port: 5433 + GinkgoParallelNode(),
   101  	}
   102  
   103  	dbProcess = ifrit.Invoke(postgresRunner)
   104  
   105  	postgresRunner.CreateTestDB()
   106  })
   107  
   108  var _ = BeforeEach(func() {
   109  	postgresRunner.Truncate()
   110  
   111  	dbConn = postgresRunner.OpenConn()
   112  
   113  	lockFactory = lock.NewLockFactory(postgresRunner.OpenSingleton(), metric.LogLockAcquired, metric.LogLockReleased)
   114  
   115  	fakeSecrets = new(credsfakes.FakeSecrets)
   116  	fakeVarSourcePool = new(credsfakes.FakeVarSourcePool)
   117  	componentFactory = db.NewComponentFactory(dbConn)
   118  	buildFactory = db.NewBuildFactory(dbConn, lockFactory, 5*time.Minute, 5*time.Minute)
   119  	volumeRepository = db.NewVolumeRepository(dbConn)
   120  	containerRepository = db.NewContainerRepository(dbConn)
   121  	teamFactory = db.NewTeamFactory(dbConn, lockFactory)
   122  	workerFactory = db.NewWorkerFactory(dbConn)
   123  	workerLifecycle = db.NewWorkerLifecycle(dbConn)
   124  	resourceConfigCheckSessionLifecycle = db.NewResourceConfigCheckSessionLifecycle(dbConn)
   125  	resourceConfigFactory = db.NewResourceConfigFactory(dbConn, lockFactory)
   126  	resourceCacheFactory = db.NewResourceCacheFactory(dbConn, lockFactory)
   127  	taskCacheFactory = db.NewTaskCacheFactory(dbConn)
   128  	checkFactory = db.NewCheckFactory(dbConn, lockFactory, fakeSecrets, fakeVarSourcePool, db.CheckDurations{
   129  		Timeout:             defaultCheckTimeout,
   130  		Interval:            defaultCheckInterval,
   131  		IntervalWithWebhook: defaultWebhookCheckInterval,
   132  	})
   133  	workerBaseResourceTypeFactory = db.NewWorkerBaseResourceTypeFactory(dbConn)
   134  	workerTaskCacheFactory = db.NewWorkerTaskCacheFactory(dbConn)
   135  	userFactory = db.NewUserFactory(dbConn)
   136  	dbWall = db.NewWall(dbConn, &fakeClock)
   137  
   138  	builder = dbtest.NewBuilder(dbConn, lockFactory)
   139  
   140  	var err error
   141  	defaultTeam, err = teamFactory.CreateTeam(atc.Team{Name: "default-team"})
   142  	Expect(err).NotTo(HaveOccurred())
   143  
   144  	defaultWorkerResourceType = atc.WorkerResourceType{
   145  		Type:    "some-base-resource-type",
   146  		Image:   "/path/to/image",
   147  		Version: "some-brt-version",
   148  	}
   149  
   150  	uniqueWorkerResourceType = atc.WorkerResourceType{
   151  		Type:                 "some-unique-base-resource-type",
   152  		Image:                "/path/to/unique/image",
   153  		Version:              "some-unique-brt-version",
   154  		UniqueVersionHistory: true,
   155  	}
   156  
   157  	certsPath := "/etc/ssl/certs"
   158  
   159  	defaultWorkerPayload = atc.Worker{
   160  		Name:            "default-worker",
   161  		GardenAddr:      "1.2.3.4:7777",
   162  		BaggageclaimURL: "5.6.7.8:7878",
   163  		CertsPath:       &certsPath,
   164  
   165  		ResourceTypes: []atc.WorkerResourceType{
   166  			defaultWorkerResourceType,
   167  			uniqueWorkerResourceType,
   168  		},
   169  	}
   170  
   171  	otherWorkerPayload = atc.Worker{
   172  		Name:            "other-worker",
   173  		GardenAddr:      "2.3.4.5:7777",
   174  		BaggageclaimURL: "6.7.8.9:7878",
   175  		CertsPath:       &certsPath,
   176  
   177  		ResourceTypes: []atc.WorkerResourceType{
   178  			defaultWorkerResourceType,
   179  			uniqueWorkerResourceType,
   180  		},
   181  	}
   182  
   183  	defaultWorker, err = workerFactory.SaveWorker(defaultWorkerPayload, 0)
   184  	Expect(err).NotTo(HaveOccurred())
   185  
   186  	otherWorker, err = workerFactory.SaveWorker(otherWorkerPayload, 0)
   187  	Expect(err).NotTo(HaveOccurred())
   188  
   189  	defaultPipelineConfig = atc.Config{
   190  		Jobs: atc.JobConfigs{
   191  			{
   192  				Name: "some-job",
   193  			},
   194  		},
   195  		Resources: atc.ResourceConfigs{
   196  			{
   197  				Name: "some-resource",
   198  				Type: "some-base-resource-type",
   199  				Source: atc.Source{
   200  					"some": "source",
   201  				},
   202  			},
   203  		},
   204  		ResourceTypes: atc.ResourceTypes{
   205  			{
   206  				Name: "some-type",
   207  				Type: "some-base-resource-type",
   208  				Source: atc.Source{
   209  					"some-type": "source",
   210  				},
   211  			},
   212  		},
   213  	}
   214  
   215  	defaultPipelineRef = atc.PipelineRef{Name: "default-pipeline", InstanceVars: atc.InstanceVars{"branch": "master"}}
   216  
   217  	defaultPipeline, _, err = defaultTeam.SavePipeline(defaultPipelineRef, defaultPipelineConfig, db.ConfigVersion(0), false)
   218  	Expect(err).NotTo(HaveOccurred())
   219  
   220  	var found bool
   221  	defaultResourceType, found, err = defaultPipeline.ResourceType("some-type")
   222  	Expect(err).NotTo(HaveOccurred())
   223  	Expect(found).To(BeTrue())
   224  
   225  	defaultResource, found, err = defaultPipeline.Resource("some-resource")
   226  	Expect(err).NotTo(HaveOccurred())
   227  	Expect(found).To(BeTrue())
   228  
   229  	defaultJob, found, err = defaultPipeline.Job("some-job")
   230  	Expect(err).NotTo(HaveOccurred())
   231  	Expect(found).To(BeTrue())
   232  
   233  	logger = lagertest.NewTestLogger("test")
   234  })
   235  
   236  func destroy(d interface{ Destroy() error }) {
   237  	err := d.Destroy()
   238  	Expect(err).ToNot(HaveOccurred())
   239  }
   240  
   241  var _ = AfterEach(func() {
   242  	err := dbConn.Close()
   243  	Expect(err).NotTo(HaveOccurred())
   244  })
   245  
   246  var _ = AfterSuite(func() {
   247  	dbProcess.Signal(os.Interrupt)
   248  	<-dbProcess.Wait()
   249  })