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

     1  package db_test
     2  
     3  import (
     4  	sq "github.com/Masterminds/squirrel"
     5  	"github.com/pf-qiu/concourse/v6/atc"
     6  	"github.com/pf-qiu/concourse/v6/atc/db"
     7  	"github.com/lib/pq"
     8  	. "github.com/onsi/ginkgo"
     9  	. "github.com/onsi/gomega"
    10  )
    11  
    12  var _ = Describe("ResourceCache", func() {
    13  	var (
    14  		resourceCacheFactory db.ResourceCacheFactory
    15  	)
    16  
    17  	BeforeEach(func() {
    18  		setupTx, err := dbConn.Begin()
    19  		Expect(err).ToNot(HaveOccurred())
    20  
    21  		brt := db.BaseResourceType{
    22  			Name: "some-worker-resource-type",
    23  		}
    24  
    25  		_, err = brt.FindOrCreate(setupTx, false)
    26  		Expect(err).NotTo(HaveOccurred())
    27  		Expect(setupTx.Commit()).To(Succeed())
    28  
    29  		resourceCacheFactory = db.NewResourceCacheFactory(dbConn, lockFactory)
    30  	})
    31  
    32  	Describe("creating for a build", func() {
    33  		var build db.Build
    34  
    35  		BeforeEach(func() {
    36  			var err error
    37  			build, err = defaultTeam.CreateOneOffBuild()
    38  			Expect(err).ToNot(HaveOccurred())
    39  		})
    40  
    41  		It("can be created and used", func() {
    42  			urc, err := resourceCacheFactory.FindOrCreateResourceCache(
    43  				db.ForBuild(build.ID()),
    44  				"some-worker-resource-type",
    45  				atc.Version{"some": "version"},
    46  				atc.Source{
    47  					"some": "source",
    48  				},
    49  				atc.Params{"some": "params"},
    50  				atc.VersionedResourceTypes{},
    51  			)
    52  			Expect(err).ToNot(HaveOccurred())
    53  			Expect(urc.ID()).ToNot(BeZero())
    54  
    55  			// ON DELETE RESTRICT from resource_cache_uses -> resource_caches
    56  			_, err = psql.Delete("resource_caches").Where(sq.Eq{"id": urc.ID()}).RunWith(dbConn).Exec()
    57  			Expect(err).To(HaveOccurred())
    58  			Expect(err.(*pq.Error).Code.Name()).To(Equal("foreign_key_violation"))
    59  		})
    60  
    61  		Context("when it already exists", func() {
    62  			var existingResourceCache db.UsedResourceCache
    63  
    64  			BeforeEach(func() {
    65  				var err error
    66  				existingResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
    67  					db.ForBuild(build.ID()),
    68  					"some-worker-resource-type",
    69  					atc.Version{"some": "version"},
    70  					atc.Source{
    71  						"some": "source",
    72  					},
    73  					atc.Params{"some": "params"},
    74  					atc.VersionedResourceTypes{},
    75  				)
    76  				Expect(err).ToNot(HaveOccurred())
    77  			})
    78  
    79  			It("returns the same used resource cache", func() {
    80  				urc, err := resourceCacheFactory.FindOrCreateResourceCache(
    81  					db.ForBuild(build.ID()),
    82  					"some-worker-resource-type",
    83  					atc.Version{"some": "version"},
    84  					atc.Source{
    85  						"some": "source",
    86  					},
    87  					atc.Params{"some": "params"},
    88  					atc.VersionedResourceTypes{},
    89  				)
    90  				Expect(err).ToNot(HaveOccurred())
    91  				Expect(urc.ID()).To(Equal(existingResourceCache.ID()))
    92  			})
    93  		})
    94  	})
    95  
    96  	Describe("creating for a container", func() {
    97  		var container db.CreatingContainer
    98  		var urc db.UsedResourceCache
    99  
   100  		BeforeEach(func() {
   101  			worker, err := defaultTeam.SaveWorker(atc.Worker{
   102  				Name: "some-worker",
   103  			}, 0)
   104  			Expect(err).ToNot(HaveOccurred())
   105  
   106  			build, err := defaultTeam.CreateOneOffBuild()
   107  			Expect(err).NotTo(HaveOccurred())
   108  
   109  			container, err = worker.CreateContainer(
   110  				db.NewBuildStepContainerOwner(build.ID(), "some-plan", defaultTeam.ID()),
   111  				db.ContainerMetadata{},
   112  			)
   113  			Expect(err).ToNot(HaveOccurred())
   114  
   115  			urc, err = resourceCacheFactory.FindOrCreateResourceCache(
   116  				db.ForContainer(container.ID()),
   117  				"some-worker-resource-type",
   118  				atc.Version{"some-type": "version"},
   119  				atc.Source{
   120  					"cache": "source",
   121  				},
   122  				atc.Params{"some": "params"},
   123  				atc.VersionedResourceTypes{},
   124  			)
   125  			Expect(err).NotTo(HaveOccurred())
   126  		})
   127  
   128  		It("resource cache cannot be deleted through use", func() {
   129  			var err error
   130  			// ON DELETE RESTRICT from resource_cache_uses -> resource_caches
   131  			_, err = psql.Delete("resource_caches").Where(sq.Eq{"id": urc.ID()}).RunWith(dbConn).Exec()
   132  			Expect(err).To(HaveOccurred())
   133  			Expect(err.(*pq.Error).Code.Name()).To(Equal("foreign_key_violation"))
   134  		})
   135  
   136  		Context("when it already exists", func() {
   137  			var existingResourceCache db.UsedResourceCache
   138  
   139  			BeforeEach(func() {
   140  				var err error
   141  				existingResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
   142  					db.ForContainer(container.ID()),
   143  					"some-worker-resource-type",
   144  					atc.Version{"some-type": "version"},
   145  					atc.Source{
   146  						"cache": "source",
   147  					},
   148  					atc.Params{"some": "params"},
   149  					atc.VersionedResourceTypes{},
   150  				)
   151  				Expect(err).NotTo(HaveOccurred())
   152  			})
   153  
   154  			It("returns the same used resource cache", func() {
   155  				Expect(urc.ID()).To(Equal(existingResourceCache.ID()))
   156  			})
   157  		})
   158  	})
   159  })