Source file src/edge-infra.dev/pkg/f8n/warehouse/release/integration/release_push_test.go

Documentation: edge-infra.dev/pkg/f8n/warehouse/release/integration

     1  package integration
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"io"
     7  	"log"
     8  	"os"
     9  	"slices"
    10  	"strings"
    11  	"testing"
    12  
    13  	"github.com/google/go-containerregistry/pkg/registry"
    14  	"github.com/stretchr/testify/assert"
    15  
    16  	"edge-infra.dev/pkg/f8n/warehouse/packagelock"
    17  	"edge-infra.dev/pkg/f8n/warehouse/pallet"
    18  	"edge-infra.dev/pkg/f8n/warehouse/release"
    19  	"edge-infra.dev/test/f2"
    20  	"edge-infra.dev/test/f2/x/warehouse"
    21  )
    22  
    23  var f f2.Framework
    24  var err error
    25  var (
    26  	reg      *warehouse.Registry
    27  	host     string
    28  	hostRepo string
    29  	ver01911 = "0.19.11"
    30  	ver02019 = "0.20.19"
    31  	ver0214  = "0.21.4"
    32  	// ver01911Minor = "0.19"
    33  	// ver02019Minor = "0.20"
    34  	ver0214Minor = "0.21"
    35  
    36  	edgeInfraRepo = release.Repository{
    37  		Repo: release.GCPRepository{
    38  			Location: "us-east1",
    39  			Project:  "ret-edge-pltf-infra",
    40  			RepoName: "warehouse",
    41  		},
    42  	}
    43  	localWarehouseRepo release.Repository
    44  
    45  	releaser01911    release.Releaser
    46  	releaser02019    release.Releaser
    47  	releaser0214     release.Releaser
    48  	smallEnvironment release.Environment
    49  	badEnvironment   release.Environment
    50  
    51  	release0214ExpectedTags = []string{ver0214, ver0214Minor, "latest"}
    52  	smallEnvironmentLock    = packagelock.PackageLock{
    53  		Packages: []packagelock.LockPackage{
    54  			{
    55  				Name: "descheduler",
    56  				Versions: []packagelock.Version{
    57  					{
    58  						Tags: []string{ver0214, ver0214Minor, "latest"},
    59  					},
    60  				},
    61  			},
    62  			{
    63  				Name: "store",
    64  				Versions: []packagelock.Version{
    65  					{
    66  						Tags: []string{ver0214, ver0214Minor, "latest"},
    67  					},
    68  				},
    69  			},
    70  			{
    71  				Name: "data-sync",
    72  				Versions: []packagelock.Version{
    73  					{
    74  						Tags: []string{ver0214, ver0214Minor, "latest"},
    75  					},
    76  				},
    77  			},
    78  		},
    79  	}
    80  
    81  	release01911 release.EdgeRelease
    82  	release02019 release.EdgeRelease
    83  	release0214  release.EdgeRelease
    84  )
    85  
    86  func TestMain(m *testing.M) {
    87  	l := log.New(io.Discard, "", 0)
    88  	f = f2.New(context.Background(), f2.WithExtensions(
    89  		warehouse.New(registry.Logger(l)),
    90  	)).Component("registry").
    91  		Setup(func(ctx f2.Context) (f2.Context, error) {
    92  			reg, err = warehouse.FromContext(ctx)
    93  			if err != nil {
    94  				return ctx, err
    95  			}
    96  			urlPts := strings.Split(reg.URL, "/")
    97  			host = urlPts[0]
    98  			hostRepo = urlPts[1]
    99  			localWarehouseRepo = release.Repository{
   100  				Repo: release.RawRepository{
   101  					RawRegistry: host,
   102  					RepoName:    hostRepo,
   103  				},
   104  			}
   105  			return ctx, nil
   106  		}).
   107  		Component("releasers and environment").
   108  		Setup(func(ctx f2.Context) (f2.Context, error) {
   109  			releaser01911 = release.Releaser{
   110  				CurrentVersion:        ver01911,
   111  				SourceRepository:      edgeInfraRepo,
   112  				DestinationRepository: localWarehouseRepo,
   113  				PalletNames: []string{
   114  					"descheduler",
   115  					"store",
   116  				},
   117  			}
   118  
   119  			releaser02019 = release.Releaser{
   120  				CurrentVersion:        ver02019,
   121  				SourceRepository:      edgeInfraRepo,
   122  				DestinationRepository: localWarehouseRepo,
   123  				PalletNames: []string{
   124  					"descheduler",
   125  					"store",
   126  					"data-sync",
   127  				},
   128  			}
   129  
   130  			releaser0214 = release.Releaser{
   131  				CurrentVersion:        ver0214,
   132  				SourceRepository:      edgeInfraRepo,
   133  				DestinationRepository: localWarehouseRepo,
   134  				PalletNames: []string{
   135  					"descheduler",
   136  					"store",
   137  					"data-sync",
   138  				},
   139  			}
   140  
   141  			smallEnvironment = release.Environment{
   142  				SourceRepository: localWarehouseRepo,
   143  				CurrentVersion:   ver0214,
   144  			}
   145  
   146  			badEnvironment = release.Environment{
   147  				SourceRepository: localWarehouseRepo,
   148  				CurrentVersion:   "0.0.0",
   149  			}
   150  			return ctx, nil
   151  		})
   152  
   153  	os.Exit(f.Run(m))
   154  }
   155  
   156  func TestBuildReleases(t *testing.T) {
   157  	ft := f2.NewFeature("build 0.20.19 release subset").
   158  		Setup("build releases from edge-infra", func(ctx f2.Context, t *testing.T) f2.Context {
   159  			release01911, err = releaser01911.BuildRelease(ctx.Context, pallet.BuildInfo{})
   160  			if err != nil {
   161  				t.Fatal(err)
   162  			}
   163  			release02019, err = releaser02019.BuildRelease(ctx.Context, pallet.BuildInfo{})
   164  			if err != nil {
   165  				t.Fatal(err)
   166  			}
   167  			release0214, err = releaser0214.BuildRelease(ctx.Context, pallet.BuildInfo{})
   168  			if err != nil {
   169  				t.Fatal(err)
   170  			}
   171  			return ctx
   172  		}).
   173  		Test("test expected pallets in releases", func(ctx f2.Context, t *testing.T) f2.Context {
   174  			for _, pall := range release01911.Pallets {
   175  				foundName := slices.Contains(releaser01911.PalletNames, pall.Name())
   176  				assert.True(t, foundName)
   177  			}
   178  			for _, pall := range release02019.Pallets {
   179  				foundName := slices.Contains(releaser02019.PalletNames, pall.Name())
   180  				assert.True(t, foundName)
   181  			}
   182  			for _, pall := range release0214.Pallets {
   183  				foundName := slices.Contains(releaser0214.PalletNames, pall.Name())
   184  				assert.True(t, foundName)
   185  			}
   186  			return ctx
   187  		}).
   188  		Test("test release metadata version is accurate", func(ctx f2.Context, t *testing.T) f2.Context {
   189  			assert.Equal(t, releaser01911.CurrentVersion, release01911.Metadata.Version)
   190  			assert.Equal(t, releaser02019.CurrentVersion, release02019.Metadata.Version)
   191  			assert.Equal(t, releaser0214.CurrentVersion, release0214.Metadata.Version)
   192  			return ctx
   193  		}).
   194  		Feature()
   195  	f.Test(t, ft)
   196  }
   197  
   198  func TestPushRelease(t *testing.T) {
   199  	ft := f2.NewFeature("test push release functionality").
   200  		Setup("push release to integration repo", func(ctx f2.Context, _ *testing.T) f2.Context {
   201  			err = releaser01911.Push(ctx, release01911)
   202  			assert.NoError(t, err)
   203  			err = releaser02019.Push(ctx, release02019)
   204  			assert.NoError(t, err)
   205  			err = releaser0214.Push(ctx, release0214)
   206  			assert.NoError(t, err)
   207  			return ctx
   208  		}).
   209  		Feature()
   210  	f.Test(t, ft)
   211  }
   212  
   213  func TestPullReleases(t *testing.T) {
   214  	ft := f2.NewFeature("pull releases from live repositories").
   215  		Setup("pull releases", func(ctx f2.Context, t *testing.T) f2.Context {
   216  			releases, err := smallEnvironment.PullReleases()
   217  			if err != nil {
   218  				t.Fatal(err)
   219  			}
   220  			assert.Len(t, releases, 1)
   221  			release0214 = releases[0]
   222  			return ctx
   223  		}).
   224  		Test("ensure release is present", func(ctx f2.Context, t *testing.T) f2.Context {
   225  			assert.Equal(t, release0214.Metadata.Version, ver0214)
   226  			return ctx
   227  		}).
   228  		Feature()
   229  	f.Test(t, ft)
   230  }
   231  
   232  func TestErrorOnMissingRelease(t *testing.T) {
   233  	ft := f2.NewFeature("attempt to pull a release that does not exist").
   234  		Test("ensure missing release errors", func(ctx f2.Context, t *testing.T) f2.Context {
   235  			releases, err := badEnvironment.PullReleases()
   236  			assert.Nil(t, releases)
   237  			assert.Error(t, err)
   238  			return ctx
   239  		}).
   240  		Feature()
   241  	f.Test(t, ft)
   242  }
   243  
   244  func TestLockSmallEnvironment(t *testing.T) {
   245  	var pl packagelock.PackageLock
   246  	ft := f2.NewFeature("lock a small environment's releases").
   247  		Setup("lock pulled releases", func(ctx f2.Context, _ *testing.T) f2.Context {
   248  			pl, err = smallEnvironment.LockReleases([]release.EdgeRelease{release0214})
   249  			fmt.Println("integration pl", pl)
   250  			return ctx
   251  		}).
   252  		Test("check pl tags match expected", func(ctx f2.Context, _ *testing.T) f2.Context {
   253  			packageCount := len(smallEnvironmentLock.Packages)
   254  			assert.Len(t, pl.Packages, len(smallEnvironmentLock.Packages))
   255  			for _, lp := range pl.Packages {
   256  				assert.Len(t, lp.Versions, 1)
   257  				for _, exLp := range smallEnvironmentLock.Packages {
   258  					assert.Len(t, lp.Versions, len(exLp.Versions))
   259  					assert.Equal(t, lp.Versions[0].Tags, release0214ExpectedTags)
   260  				}
   261  				packageCount--
   262  			}
   263  			assert.Equal(t, packageCount, 0)
   264  			return ctx
   265  		}).
   266  		Feature()
   267  	f.Test(t, ft)
   268  }
   269  
   270  // func TestContainedReleaseE2E(t *testing.T) {
   271  // 	// var reg *warehouse.Registry
   272  // 	// var host string
   273  // 	// var projectID string
   274  // 	// Pallets
   275  // 	var (
   276  // 		storePalletName = "store"
   277  // 		// storePallet          pallet.Pallet
   278  // 		storeDigest          v1.Hash
   279  // 		cloudInfraPalletName = "cloud-infra"
   280  // 		// cloudInfraPallet     pallet.Pallet
   281  // 		cloudInfraDigest v1.Hash
   282  // 	)
   283  
   284  // 	// Release
   285  // 	var (
   286  // 		testRelease  release.EdgeRelease
   287  // 		testManifest *v1.IndexManifest
   288  // 	)
   289  
   290  // 	sourceRepoName := "f2repo"
   291  
   292  // 	releasePallets := []string{storePalletName, cloudInfraPalletName}
   293  
   294  // 	ft := f2.NewFeature("push").
   295  // 		Setup("add store pallet", func(ctx f2.Context, t *testing.T) f2.Context {
   296  // 			// create and push an artifact to the test registry
   297  // 			l, err := layer.New(layer.Runtime, []byte("hello"))
   298  // 			if err != nil {
   299  // 				t.Fatal(err)
   300  // 			}
   301  // 			layers := []layer.Layer{l}
   302  // 			storePallet, err := pallet.Image(pallet.Options{
   303  // 				Metadata: pallet.Metadata{
   304  // 					Name: storePalletName,
   305  // 					Team: "f8n",
   306  // 					BuildInfo: pallet.BuildInfo{
   307  // 						Created:  "yesterday",
   308  // 						Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
   309  // 						Revision: "d34db33f",
   310  // 						Version:  ver02019,
   311  // 					},
   312  // 				},
   313  // 				ClusterProviders: cluster.BuiltInProviders(),
   314  // 			}, layers...)
   315  // 			if err != nil {
   316  // 				t.Fatal("failed to create test pallet", storePalletName, err)
   317  // 			}
   318  // 			storeDigest, err = storePallet.Digest()
   319  // 			if err != nil {
   320  // 				t.Fatal(err)
   321  // 			}
   322  
   323  // 			tag := ver02019
   324  // 			pushPath := fmt.Sprintf("%s/%s", sourceRepoName, storePalletName)
   325  // 			if err := reg.Push(storePallet, pushPath, tag, remote.WithoutAuth()); err != nil {
   326  // 				t.Fatal("failed to push test pallet", err)
   327  // 			}
   328  
   329  // 			fmt.Println("pushed store pallet")
   330  // 			return ctx
   331  // 		}).
   332  // 		Setup("add cloud-infra pallet", func(ctx f2.Context, t *testing.T) f2.Context {
   333  // 			// create and push an artifact to the test registry
   334  // 			l, err := layer.New(layer.Runtime, []byte("its infra time"))
   335  // 			if err != nil {
   336  // 				t.Fatal(err)
   337  // 			}
   338  // 			layers := []layer.Layer{l}
   339  // 			cloudInfraPallet, err := pallet.Image(pallet.Options{
   340  // 				Metadata: pallet.Metadata{
   341  // 					Name: cloudInfraPalletName,
   342  // 					Team: "f8n",
   343  // 					BuildInfo: pallet.BuildInfo{
   344  // 						Created:  "yesterday",
   345  // 						Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
   346  // 						Revision: "d34db33f",
   347  // 						Version:  ver02019,
   348  // 					},
   349  // 				},
   350  // 				ClusterProviders: cluster.BuiltInProviders(),
   351  // 			}, layers...)
   352  // 			if err != nil {
   353  // 				t.Fatal("failed to create test pallet", cloudInfraPalletName, err)
   354  // 			}
   355  // 			cloudInfraDigest, err = cloudInfraPallet.Digest()
   356  // 			if err != nil {
   357  // 				t.Fatal(err)
   358  // 			}
   359  
   360  // 			tag := ver02019
   361  // 			pushPath := fmt.Sprintf("%s/%s", sourceRepoName, cloudInfraPalletName)
   362  // 			if err := reg.Push(cloudInfraPallet, pushPath, tag, remote.WithoutAuth()); err != nil {
   363  // 				t.Fatal("failed to push test pallet", err)
   364  // 			}
   365  
   366  // 			fmt.Println("pushed cloud-infra pallet")
   367  // 			return ctx
   368  // 		}).
   369  // 		Test("build release", func(ctx f2.Context, t *testing.T) f2.Context {
   370  // 			sourceRepo := release.Repository{
   371  // 				Repo: release.RawRepository{
   372  // 					RawRegistry: reg.URL,
   373  // 					RepoName:    sourceRepoName,
   374  // 				},
   375  // 			}
   376  // 			releaser := &release.Releaser{
   377  // 				CurrentVersion:   ver02019,
   378  // 				SourceRepository: sourceRepo,
   379  // 				PalletNames:      releasePallets,
   380  // 			}
   381  
   382  // 			fmt.Println("build release")
   383  // 			testRelease, err = releaser.BuildRelease(ctx.Context, pallet.BuildInfo{})
   384  // 			if err != nil {
   385  // 				t.Fatal(err)
   386  // 			}
   387  
   388  // 			testIdx, isIdx := testRelease.Artifact.(v1.ImageIndex)
   389  // 			if !isIdx {
   390  // 				t.Fatal("release is not index")
   391  // 				return ctx
   392  // 			}
   393  // 			idxBytes, err := testIdx.RawManifest()
   394  // 			if err != nil {
   395  // 				t.Fatal("could not get raw manifest")
   396  // 			}
   397  // 			fmt.Println(string(idxBytes))
   398  
   399  // 			testManifest, err = testIdx.IndexManifest()
   400  // 			if err != nil {
   401  // 				fmt.Println(err)
   402  // 				t.Fatal(err)
   403  // 				return ctx
   404  // 			}
   405  
   406  // 			return ctx
   407  // 		}).
   408  // 		Test("check store artifact", func(ctx f2.Context, t *testing.T) f2.Context {
   409  // 			var storeDescr v1.Descriptor
   410  // 			for _, descr := range testManifest.Manifests {
   411  // 				fmt.Println(descr.Annotations)
   412  // 				if annoName, found := descr.Annotations[wh.AnnotationName]; found && annoName == storePalletName {
   413  // 					storeDescr = descr
   414  // 					break
   415  // 				}
   416  // 			}
   417  
   418  // 			if storeDescr.Size == 0 {
   419  // 				t.Fatal("could not find store artifact in test release manifests")
   420  // 				return ctx
   421  // 			}
   422  
   423  // 			if storeDigest.Hex != storeDescr.Digest.Hex {
   424  // 				fmt.Println("store digest did not match")
   425  // 				fmt.Println("got", storeDescr.Digest.Hex)
   426  // 				fmt.Println("wanted", storeDigest.Hex)
   427  // 				t.Fatal("store digest did not match")
   428  // 			}
   429  
   430  // 			fmt.Println("store artifact found successfully")
   431  // 			return ctx
   432  // 		}).
   433  // 		Test("check cloud artifact", func(ctx f2.Context, t *testing.T) f2.Context {
   434  // 			var cloudDescr v1.Descriptor
   435  // 			for _, descr := range testManifest.Manifests {
   436  // 				if annoName, found := descr.Annotations[wh.AnnotationName]; found && annoName == cloudInfraPalletName {
   437  // 					cloudDescr = descr
   438  // 					break
   439  // 				}
   440  // 			}
   441  
   442  // 			if cloudDescr.Size == 0 {
   443  // 				t.Fatal("could not find cloud infra artifact in test release manifests")
   444  // 				return ctx
   445  // 			}
   446  
   447  // 			if cloudInfraDigest.Hex != cloudDescr.Digest.Hex {
   448  // 				fmt.Println("cloud digest did not match")
   449  // 				fmt.Println("got", cloudDescr.Digest.Hex)
   450  // 				fmt.Println("wanted", cloudInfraDigest.Hex)
   451  // 				t.Fatal("cloud digest did not match")
   452  // 			}
   453  // 			fmt.Println("cloud artifact found successfully")
   454  
   455  // 			return ctx
   456  // 		}).
   457  // 		Feature()
   458  
   459  // 	f.Test(t, ft)
   460  // }
   461  

View as plain text