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

     1  package db_test
     2  
     3  import (
     4  	"github.com/pf-qiu/concourse/v6/atc"
     5  	"github.com/pf-qiu/concourse/v6/atc/db"
     6  
     7  	. "github.com/onsi/ginkgo"
     8  	. "github.com/onsi/gomega"
     9  )
    10  
    11  var _ = Describe("WorkerResourceCache", func() {
    12  	var workerResourceCache db.WorkerResourceCache
    13  
    14  	Describe("FindOrCreate", func() {
    15  		BeforeEach(func() {
    16  			build, err := defaultTeam.CreateOneOffBuild()
    17  			Expect(err).ToNot(HaveOccurred())
    18  
    19  			resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
    20  				db.ForBuild(build.ID()),
    21  				"some-base-resource-type",
    22  				atc.Version{"some": "version"},
    23  				atc.Source{"some": "source"},
    24  				atc.Params{},
    25  				atc.VersionedResourceTypes{},
    26  			)
    27  			Expect(err).ToNot(HaveOccurred())
    28  
    29  			workerResourceCache = db.WorkerResourceCache{
    30  				ResourceCache: resourceCache,
    31  				WorkerName:    defaultWorker.Name(),
    32  			}
    33  		})
    34  
    35  		Context("when there are no existing worker resource caches", func() {
    36  			It("creates worker resource cache", func() {
    37  				tx, err := dbConn.Begin()
    38  				Expect(err).ToNot(HaveOccurred())
    39  				defer db.Rollback(tx)
    40  
    41  				usedWorkerResourceCache, err := workerResourceCache.FindOrCreate(tx)
    42  				Expect(err).ToNot(HaveOccurred())
    43  
    44  				Expect(usedWorkerResourceCache.ID).To(Equal(1))
    45  			})
    46  		})
    47  
    48  		Context("when there is existing worker resource caches", func() {
    49  			BeforeEach(func() {
    50  				var err error
    51  				tx, err := dbConn.Begin()
    52  				Expect(err).ToNot(HaveOccurred())
    53  
    54  				_, err = workerResourceCache.FindOrCreate(tx)
    55  				Expect(err).ToNot(HaveOccurred())
    56  
    57  				Expect(tx.Commit()).To(Succeed())
    58  			})
    59  
    60  			It("finds worker resource cache", func() {
    61  				tx, err := dbConn.Begin()
    62  				Expect(err).ToNot(HaveOccurred())
    63  				defer db.Rollback(tx)
    64  
    65  				usedWorkerResourceCache, err := workerResourceCache.FindOrCreate(tx)
    66  				Expect(err).ToNot(HaveOccurred())
    67  
    68  				Expect(usedWorkerResourceCache.ID).To(Equal(1))
    69  			})
    70  		})
    71  	})
    72  
    73  	Describe("Find", func() {
    74  		var foundWRC *db.UsedWorkerResourceCache
    75  		var found bool
    76  		var findErr error
    77  
    78  		BeforeEach(func() {
    79  			build, err := defaultTeam.CreateOneOffBuild()
    80  			Expect(err).ToNot(HaveOccurred())
    81  
    82  			resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
    83  				db.ForBuild(build.ID()),
    84  				"some-base-resource-type",
    85  				atc.Version{"some": "version"},
    86  				atc.Source{"some": "source"},
    87  				atc.Params{},
    88  				atc.VersionedResourceTypes{},
    89  			)
    90  			Expect(err).ToNot(HaveOccurred())
    91  
    92  			workerResourceCache = db.WorkerResourceCache{
    93  				ResourceCache: resourceCache,
    94  				WorkerName:    defaultWorker.Name(),
    95  			}
    96  		})
    97  
    98  		JustBeforeEach(func() {
    99  			tx, err := dbConn.Begin()
   100  			Expect(err).ToNot(HaveOccurred())
   101  			defer db.Rollback(tx)
   102  
   103  			foundWRC, found, findErr = workerResourceCache.Find(tx)
   104  		})
   105  
   106  		Context("when there are no existing worker resource caches", func() {
   107  			It("returns false and no error", func() {
   108  				Expect(findErr).ToNot(HaveOccurred())
   109  				Expect(found).To(BeFalse())
   110  				Expect(foundWRC).To(BeNil())
   111  			})
   112  		})
   113  
   114  		Context("when the base resource type does not exist on the worker", func() {
   115  			BeforeEach(func() {
   116  				tx, err := dbConn.Begin()
   117  				Expect(err).ToNot(HaveOccurred())
   118  
   119  				defer db.Rollback(tx)
   120  
   121  				_, err = db.BaseResourceType{
   122  					Name: "some-bogus-resource-type",
   123  				}.FindOrCreate(tx, false)
   124  				Expect(err).ToNot(HaveOccurred())
   125  
   126  				err = tx.Commit()
   127  				Expect(err).ToNot(HaveOccurred())
   128  
   129  				build, err := defaultTeam.CreateOneOffBuild()
   130  				Expect(err).ToNot(HaveOccurred())
   131  
   132  				resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
   133  					db.ForBuild(build.ID()),
   134  					"some-bogus-resource-type",
   135  					atc.Version{"some": "version"},
   136  					atc.Source{"some": "source"},
   137  					atc.Params{},
   138  					atc.VersionedResourceTypes{},
   139  				)
   140  				Expect(err).ToNot(HaveOccurred())
   141  
   142  				workerResourceCache.ResourceCache = resourceCache
   143  			})
   144  
   145  			It("returns false and no error", func() {
   146  				Expect(found).To(BeFalse())
   147  				Expect(foundWRC).To(BeNil())
   148  			})
   149  		})
   150  
   151  		Context("when there is existing worker resource caches", func() {
   152  			var createdWorkerResourceCache *db.UsedWorkerResourceCache
   153  
   154  			BeforeEach(func() {
   155  				var err error
   156  				tx, err := dbConn.Begin()
   157  				Expect(err).ToNot(HaveOccurred())
   158  
   159  				createdWorkerResourceCache, err = workerResourceCache.FindOrCreate(tx)
   160  				Expect(err).ToNot(HaveOccurred())
   161  
   162  				Expect(tx.Commit()).To(Succeed())
   163  			})
   164  
   165  			It("finds worker resource cache", func() {
   166  				Expect(findErr).ToNot(HaveOccurred())
   167  				Expect(found).To(BeTrue())
   168  				Expect(foundWRC.ID).To(Equal(createdWorkerResourceCache.ID))
   169  			})
   170  		})
   171  	})
   172  })