src/pkg/dkms/versions_test.go

package dkms

import (
	"context"
	"fmt"
	"testing"

	"cos.googlesource.com/cos/tools.git/src/pkg/fakes"
	"cos.googlesource.com/cos/tools.git/src/pkg/fs"
	"cos.googlesource.com/cos/tools.git/src/pkg/gcs"
)

func TestCompareVersions(t *testing.T) {
	sortedVersions := []string{
		"1.0",
		"1.0.0",
		"2.0.0",
		"2.1.0",
		"2.1.1",
		"2.1.1-a",
		"2.1.1-b",
		"2.3.100",
		"2.10.1",
		"3.0.0",
	}

	for i := 0; i < len(sortedVersions); i++ {
		for j := 0; j < len(sortedVersions); j++ {
			a := sortedVersions[i]
			b := sortedVersions[j]
			comparison := CompareVersions(a, b)
			if i < j && comparison >= 0 {
				t.Fatalf("version %s should be less than %s", a, b)
			} else if i == j && comparison != 0 {
				t.Fatalf("version %s should be equal to %s", a, b)
			} else if i > j && comparison <= 0 {
				t.Fatalf("version %s should be greater than %s", a, b)
			}
		}
	}
}

type compatibleVersionTestCase struct {
	pkg Package
	compatible bool
}

func compatibleVersionsTestCases(trees *Trees) []compatibleVersionTestCase {
	return []compatibleVersionTestCase {
		{
			pkg: Package {
				Name: "mypackage",
				Version: "0.0.1",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: true,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "0.1.0",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: true,
		},
		{
			pkg: Package {
				Name: "mypackage-2", // different name
				Version: "1.3.0",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: false,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "1.3.1",
				KernelVersion: "6.6.60", // different kernel version
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: false,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "1.3.4",
				KernelVersion: "6.6.59",
				Arch: "arm64", // different arch
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: false,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "1.3.5",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12346.0.0", // different build id
				Board: "lakitu",
				Trees: trees,
			},
			compatible: false,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "1.3.6",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu-2", // different board
				Trees: trees,
			},
			compatible: false,
		},
		{
			pkg: Package {
				Name: "mypackage",
				Version: "1.1.0",
				KernelVersion: "6.6.59",
				Arch: "x86_64",
				BuildId: "12345.0.0",
				Board: "lakitu",
				Trees: trees,
			},
			compatible: true,
		},
	}
}

func TestCompatiblePackageVersions(t *testing.T) {
	srcDir := t.TempDir()
	trees := &Trees {
		Dkms: t.TempDir(),
		Source: srcDir,
	}
	testCases := compatibleVersionsTestCases(trees)

	options := Options {}

	for _, testCase := range testCases {
		err := fs.CopyDir("testdata/source-tree/mymodule-1.0", fmt.Sprintf("%s/%s-%s", srcDir, testCase.pkg.Name, testCase.pkg.Version), 0777)
		if err != nil {
			t.Fatalf("failed to create package sources: %v", err)
		}
		if err := Add(&testCase.pkg, &options); err != nil {
			t.Fatalf("error adding package: %v", err)
		}
	}

	containsString := func (strings []string, s string) bool {
		for _, t := range strings {
			if s == t {
				return true
			}
		}
		return false
	}

	testPackage := testCases[0].pkg
	compatibleVersions, err := CompatiblePackageVersions(&testPackage)
	if err != nil {
		t.Fatalf("%v", err)
	}
	for _, testCase := range testCases {
		if testCase.compatible {
			if !containsString(compatibleVersions, testCase.pkg.Version) {
				t.Fatalf("expected version %s to be in compatible versions list", testCase.pkg.Version)
			}
		} else {
			if containsString(compatibleVersions, testCase.pkg.Version) {
				t.Fatalf("expected version %s not to be in compatible versions list", testCase.pkg.Version)
			}
		}
	}
}

func TestCachedCompatiblePackageVersions(t *testing.T) {
	srcDir := t.TempDir()
	trees := &Trees {
		Dkms: t.TempDir(),
		Source: srcDir,
	}
	testCases := compatibleVersionsTestCases(trees)

	fakeGCS := fakes.GCSForTest(t)
	fakeGCS.LogMissing = false
	cache := gcs.NewGCSBucket(fakeGCS.Client, "test", "test/prefix/")

	options := Options {
		Upload: true,
	}

	for _, testCase := range testCases {
		err := fs.CopyDir("testdata/source-tree/mymodule-1.0", fmt.Sprintf("%s/%s-%s", srcDir, testCase.pkg.Name, testCase.pkg.Version), 0777)
		if err != nil {
			t.Fatalf("failed to create package sources: %v", err)
		}
		if err := CachedAdd(context.Background(), &testCase.pkg, cache, &options); err != nil {
			t.Fatalf("error adding package: %v", err)
		}
	}

	containsString := func (strings []string, s string) bool {
		for _, t := range strings {
			if s == t {
				return true
			}
		}
		return false
	}

	testPackage := testCases[0].pkg
	compatibleVersions, err := CachedCompatiblePackageVersions(context.Background(), &testPackage, cache)
	if err != nil {
		t.Fatalf("%v", err)
	}
	for _, testCase := range testCases {
		if testCase.compatible {
			if !containsString(compatibleVersions, testCase.pkg.Version) {
				t.Fatalf("expected version %s to be in compatible versions list", testCase.pkg.Version)
			}
		} else {
			if containsString(compatibleVersions, testCase.pkg.Version) {
				t.Fatalf("expected version %s not to be in compatible versions list", testCase.pkg.Version)
			}
		}
	}
}