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

     1  package gc_test
     2  
     3  import (
     4  	"context"
     5  	"os"
     6  	"time"
     7  
     8  	"code.cloudfoundry.org/lager"
     9  
    10  	"code.cloudfoundry.org/lager/lagertest"
    11  
    12  	sq "github.com/Masterminds/squirrel"
    13  	"github.com/pf-qiu/concourse/v6/atc"
    14  	"github.com/pf-qiu/concourse/v6/atc/db"
    15  	"github.com/pf-qiu/concourse/v6/atc/db/dbtest"
    16  	"github.com/pf-qiu/concourse/v6/atc/db/lock"
    17  	"github.com/pf-qiu/concourse/v6/atc/postgresrunner"
    18  	. "github.com/onsi/ginkgo"
    19  	. "github.com/onsi/gomega"
    20  	"github.com/tedsuo/ifrit"
    21  
    22  	"testing"
    23  )
    24  
    25  type GcCollector interface {
    26  	Run(context.Context) error
    27  }
    28  
    29  func TestGc(t *testing.T) {
    30  	RegisterFailHandler(Fail)
    31  	RunSpecs(t, "Gc Suite")
    32  }
    33  
    34  var psql = sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
    35  
    36  var (
    37  	postgresRunner postgresrunner.Runner
    38  	dbProcess      ifrit.Process
    39  
    40  	dbConn                 db.Conn
    41  	err                    error
    42  	resourceCacheFactory   db.ResourceCacheFactory
    43  	resourceCacheLifecycle db.ResourceCacheLifecycle
    44  	resourceConfigFactory  db.ResourceConfigFactory
    45  	buildFactory           db.BuildFactory
    46  	lockFactory            lock.LockFactory
    47  
    48  	teamFactory db.TeamFactory
    49  
    50  	defaultTeam        db.Team
    51  	defaultPipeline    db.Pipeline
    52  	defaultPipelineRef atc.PipelineRef
    53  	defaultJob         db.Job
    54  	defaultBuild       db.Build
    55  
    56  	usedResource     db.Resource
    57  	usedResourceType db.ResourceType
    58  
    59  	builder dbtest.Builder
    60  
    61  	logger      *lagertest.TestLogger
    62  	fakeLogFunc = func(logger lager.Logger, id lock.LockID) {}
    63  )
    64  
    65  var _ = BeforeSuite(func() {
    66  	postgresRunner = postgresrunner.Runner{
    67  		Port: 5433 + GinkgoParallelNode(),
    68  	}
    69  
    70  	dbProcess = ifrit.Invoke(postgresRunner)
    71  
    72  	postgresRunner.CreateTestDB()
    73  })
    74  
    75  var _ = BeforeEach(func() {
    76  	postgresRunner.Truncate()
    77  
    78  	dbConn = postgresRunner.OpenConn()
    79  
    80  	lockFactory = lock.NewLockFactory(postgresRunner.OpenSingleton(), fakeLogFunc, fakeLogFunc)
    81  
    82  	builder = dbtest.NewBuilder(dbConn, lockFactory)
    83  
    84  	teamFactory = db.NewTeamFactory(dbConn, lockFactory)
    85  	buildFactory = db.NewBuildFactory(dbConn, lockFactory, 0, time.Hour)
    86  
    87  	defaultTeam, err = teamFactory.CreateTeam(atc.Team{Name: "default-team"})
    88  	Expect(err).NotTo(HaveOccurred())
    89  
    90  	defaultBuild, err = defaultTeam.CreateOneOffBuild()
    91  	Expect(err).NotTo(HaveOccurred())
    92  
    93  	atcConfig := atc.Config{
    94  		Resources: atc.ResourceConfigs{
    95  			{
    96  				Name:   "some-resource",
    97  				Type:   "some-base-type",
    98  				Source: atc.Source{"some": "source"},
    99  			},
   100  		},
   101  		ResourceTypes: atc.ResourceTypes{
   102  			{
   103  				Name:   "some-resource-type",
   104  				Type:   "some-base-type",
   105  				Source: atc.Source{"some": "source-type"},
   106  			},
   107  		},
   108  		Jobs: atc.JobConfigs{
   109  			{
   110  				Name: "some-job",
   111  			},
   112  			{
   113  				Name: "some-other-job",
   114  			},
   115  		},
   116  	}
   117  
   118  	defaultPipelineRef = atc.PipelineRef{Name: "default-pipeline"}
   119  	defaultPipeline, _, err = defaultTeam.SavePipeline(defaultPipelineRef, atcConfig, db.ConfigVersion(0), false)
   120  	Expect(err).NotTo(HaveOccurred())
   121  
   122  	var found bool
   123  	defaultJob, found, err = defaultPipeline.Job("some-job")
   124  	Expect(err).NotTo(HaveOccurred())
   125  	Expect(found).To(BeTrue())
   126  
   127  	usedResource, found, err = defaultPipeline.Resource("some-resource")
   128  	Expect(err).NotTo(HaveOccurred())
   129  	Expect(found).To(BeTrue())
   130  
   131  	usedResourceType, found, err = defaultPipeline.ResourceType("some-resource-type")
   132  	Expect(err).NotTo(HaveOccurred())
   133  	Expect(found).To(BeTrue())
   134  
   135  	setupTx, err := dbConn.Begin()
   136  	Expect(err).ToNot(HaveOccurred())
   137  
   138  	baseResourceType := db.BaseResourceType{
   139  		Name: "some-base-type",
   140  	}
   141  
   142  	_, err = baseResourceType.FindOrCreate(setupTx, false)
   143  	Expect(err).NotTo(HaveOccurred())
   144  
   145  	Expect(setupTx.Commit()).To(Succeed())
   146  
   147  	logger = lagertest.NewTestLogger("gc-test")
   148  
   149  	resourceCacheLifecycle = db.NewResourceCacheLifecycle(dbConn)
   150  	resourceCacheFactory = db.NewResourceCacheFactory(dbConn, lockFactory)
   151  	resourceConfigFactory = db.NewResourceConfigFactory(dbConn, lockFactory)
   152  })
   153  
   154  var _ = AfterEach(func() {
   155  	Expect(dbConn.Close()).To(Succeed())
   156  })
   157  
   158  var _ = AfterSuite(func() {
   159  	dbProcess.Signal(os.Interrupt)
   160  	Eventually(dbProcess.Wait(), 10*time.Second).Should(Receive())
   161  })