From 8b0f1b7c399339521ec46785967cc0672e29a83e Mon Sep 17 00:00:00 2001 From: Sascha Grunert Date: Thu, 14 May 2020 15:26:05 +0200 Subject: [PATCH] Enhance kubepkg testing This bumps the test coverage of kubepkg and separates the test more from the actual implementation. Signed-off-by: Sascha Grunert --- pkg/kubepkg/BUILD.bazel | 6 +- pkg/kubepkg/kubepkg.go | 127 +++++---- pkg/kubepkg/kubepkg_test.go | 225 ++++++++++++---- pkg/kubepkg/kubepkgfakes/BUILD.bazel | 27 ++ pkg/kubepkg/kubepkgfakes/fake_impl.go | 369 ++++++++++++++++++++++++++ 5 files changed, 650 insertions(+), 104 deletions(-) create mode 100644 pkg/kubepkg/kubepkgfakes/BUILD.bazel create mode 100644 pkg/kubepkg/kubepkgfakes/fake_impl.go diff --git a/pkg/kubepkg/BUILD.bazel b/pkg/kubepkg/BUILD.bazel index 435fd01a1ca..113b804bdb5 100644 --- a/pkg/kubepkg/BUILD.bazel +++ b/pkg/kubepkg/BUILD.bazel @@ -15,6 +15,7 @@ go_library( "//pkg/release:go_default_library", "//pkg/util:go_default_library", "@com_github_blang_semver//:go_default_library", + "@com_github_google_go_github_v29//github:go_default_library", "@com_github_pkg_errors//:go_default_library", "@com_github_sirupsen_logrus//:go_default_library", ], @@ -31,6 +32,7 @@ filegroup( name = "all-srcs", srcs = [ ":package-srcs", + "//pkg/kubepkg/kubepkgfakes:all-srcs", "//pkg/kubepkg/options:all-srcs", ], tags = ["automanaged"], @@ -42,9 +44,9 @@ go_test( srcs = ["kubepkg_test.go"], embed = [":go_default_library"], deps = [ - "//pkg/github/githubfakes:go_default_library", + "//pkg/kubepkg/kubepkgfakes:go_default_library", "//pkg/kubepkg/options:go_default_library", - "//pkg/release/releasefakes:go_default_library", + "@com_github_pkg_errors//:go_default_library", "@com_github_stretchr_testify//require:go_default_library", ], ) diff --git a/pkg/kubepkg/kubepkg.go b/pkg/kubepkg/kubepkg.go index 4f26d778aa8..a130c107284 100644 --- a/pkg/kubepkg/kubepkg.go +++ b/pkg/kubepkg/kubepkg.go @@ -29,6 +29,7 @@ import ( "github.com/pkg/errors" "github.com/sirupsen/logrus" + gogithub "github.com/google/go-github/v29/github" "k8s.io/release/pkg/command" "k8s.io/release/pkg/github" "k8s.io/release/pkg/kubepkg/options" @@ -44,8 +45,8 @@ const ( ChannelNightly ChannelType = "nightly" minimumKubernetesVersion = "1.13.0" - minimumCNIVersion = "0.7.5" - pre117CNIVersion = "0.7.5" + MinimumCNIVersion = "0.7.5" + Pre117CNIVersion = "0.7.5" kubeadmConf = "10-kubeadm.conf" ) @@ -85,18 +86,47 @@ var ( type Client struct { options *options.Options - version *release.Version - github *github.GitHub + impl Impl } func New(o *options.Options) *Client { return &Client{ options: o, - version: release.NewVersion(), - github: github.New(), + impl: &impl{}, } } +func (c *Client) SetImpl(impl Impl) { + c.impl = impl +} + +type impl struct{} + +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate +//counterfeiter:generate . Impl +type Impl interface { + RunSuccessWithWorkDir(workDir, cmd string, args ...string) error + RunSuccess(workDir, cmd string, args ...string) error + Releases(owner, repo string, includePrereleases bool) ([]*gogithub.RepositoryRelease, error) + GetKubeVersion(versionType release.VersionType) (string, error) +} + +func (i *impl) RunSuccessWithWorkDir(workDir, cmd string, args ...string) error { + return command.NewWithWorkDir(workDir, cmd, args...).RunSuccess() +} + +func (i *impl) RunSuccess(workDir, cmd string, args ...string) error { + return command.New(cmd, args...).RunSuccess() +} + +func (i *impl) Releases(owner, repo string, includePrereleases bool) ([]*gogithub.RepositoryRelease, error) { + return github.New().Releases(owner, repo, includePrereleases) +} + +func (i *impl) GetKubeVersion(versionType release.VersionType) (string, error) { + return release.NewVersion().GetKubeVersion(versionType) +} + type Build struct { Type options.BuildType Package string @@ -250,12 +280,12 @@ func (c *Client) buildPackage(build Build, packageDef *PackageDefinition, arch, } } - bc.KubernetesVersion, err = c.getKubernetesVersion(pd) + bc.KubernetesVersion, err = c.GetKubernetesVersion(pd) if err != nil { return errors.Wrap(err, "getting Kubernetes version") } - bc.DownloadLinkBase, err = c.getDownloadLinkBase(pd) + bc.DownloadLinkBase, err = c.GetDownloadLinkBase(pd) if err != nil { return errors.Wrap(err, "getting Kubernetes download link base") } @@ -266,14 +296,14 @@ func (c *Client) buildPackage(build Build, packageDef *PackageDefinition, arch, // of "+" with "-", so that we build with a valid Debian package version. bc.KubernetesVersion = strings.Replace(bc.KubernetesVersion, "+", "-", 1) - bc.Version, err = c.getPackageVersion(pd) + bc.Version, err = c.GetPackageVersion(pd) if err != nil { return errors.Wrap(err, "getting package version") } logrus.Infof("%s package version: %s", bc.Name, bc.Version) - bc.Dependencies, err = getDependencies(pd) + bc.Dependencies, err = GetDependencies(pd) if err != nil { return errors.Wrap(err, "getting dependencies") } @@ -282,16 +312,16 @@ func (c *Client) buildPackage(build Build, packageDef *PackageDefinition, arch, bc.BuildArch = getBuildArch(bc.GoArch, bc.Type) - bc.CNIDownloadLink, err = getCNIDownloadLink(pd, bc.GoArch) + bc.CNIDownloadLink, err = GetCNIDownloadLink(pd, bc.GoArch) if err != nil { return errors.Wrap(err, "getting CNI download link") } logrus.Infof("Building %s package for %s/%s architecture...", bc.Package, bc.GoArch, bc.BuildArch) - return bc.run() + return c.run(bc) } -func (bc *buildConfig) run() error { +func (c *Client) run(bc *buildConfig) error { workspaceInfo, err := os.Stat(bc.workspace) if err != nil { return err @@ -323,7 +353,7 @@ func (bc *buildConfig) run() error { case options.BuildDeb: logrus.Infof("Running dpkg-buildpackage for %s (%s/%s)", bc.Package, bc.GoArch, bc.BuildArch) - dpkgErr := command.NewWithWorkDir( + if err := c.impl.RunSuccessWithWorkDir( specDirWithArch, "dpkg-buildpackage", "--unsigned-source", @@ -331,23 +361,22 @@ func (bc *buildConfig) run() error { "--build=binary", "--host-arch", bc.BuildArch, - ).RunSuccess() - - if dpkgErr != nil { - return dpkgErr + ); err != nil { + return errors.Wrap(err, "running debian package build") } fileName := fmt.Sprintf("%s_%s-%s_%s.deb", bc.Package, bc.Version, bc.Revision, bc.BuildArch) dstParts := []string{"bin", string(bc.Channel), fileName} dstPath := filepath.Join(dstParts...) - if mkdirErr := os.MkdirAll(dstPath, os.FileMode(0777)); mkdirErr != nil { - return mkdirErr + if err := os.MkdirAll(dstPath, os.FileMode(0777)); err != nil { + return err } - mvErr := command.New("mv", filepath.Join(specDir, fileName), dstPath).RunSuccess() - if mvErr != nil { - return mvErr + if err := c.impl.RunSuccess( + "mv", filepath.Join(specDir, fileName), dstPath, + ); err != nil { + return err } logrus.Infof("Successfully built %s", dstPath) @@ -358,7 +387,7 @@ func (bc *buildConfig) run() error { return nil } -func (c *Client) getPackageVersion(packageDef *PackageDefinition) (string, error) { +func (c *Client) GetPackageVersion(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -366,9 +395,9 @@ func (c *Client) getPackageVersion(packageDef *PackageDefinition) (string, error logrus.Infof("Setting version for %s package...", packageDef.Name) switch packageDef.Name { case "kubernetes-cni": - return getCNIVersion(packageDef) + return GetCNIVersion(packageDef) case "cri-tools": - return c.getCRIToolsVersion(packageDef) + return c.GetCRIToolsVersion(packageDef) } logrus.Infof( @@ -378,7 +407,7 @@ func (c *Client) getPackageVersion(packageDef *PackageDefinition) (string, error return util.TrimTagPrefix(packageDef.KubernetesVersion), nil } -func (c *Client) getKubernetesVersion(packageDef *PackageDefinition) (string, error) { +func (c *Client) GetKubernetesVersion(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -389,15 +418,15 @@ func (c *Client) getKubernetesVersion(packageDef *PackageDefinition) (string, er } switch packageDef.Channel { case ChannelTesting: - return c.version.GetKubeVersion(release.VersionTypeStablePreRelease) + return c.impl.GetKubeVersion(release.VersionTypeStablePreRelease) case ChannelNightly: - return c.version.GetKubeVersion(release.VersionTypeCILatest) + return c.impl.GetKubeVersion(release.VersionTypeCILatest) } - return c.version.GetKubeVersion(release.VersionTypeStable) + return c.impl.GetKubeVersion(release.VersionTypeStable) } -func getCNIVersion(packageDef *PackageDefinition) (string, error) { +func GetCNIVersion(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -416,20 +445,20 @@ func getCNIVersion(packageDef *PackageDefinition) (string, error) { if packageDef.Version != "" { if kubeSemver.LT(v117) { - logrus.Infof("Kubernetes version earlier than 1.17 must use CNI version <= %s", pre117CNIVersion) - logrus.Infof("Setting CNI version to %s", pre117CNIVersion) - return pre117CNIVersion, nil + logrus.Infof("Kubernetes version earlier than 1.17 must use CNI version <= %s", Pre117CNIVersion) + logrus.Infof("Setting CNI version to %s", Pre117CNIVersion) + return Pre117CNIVersion, nil } logrus.Infof("Setting CNI version to %s", packageDef.Version) return packageDef.Version, nil } - logrus.Infof("Setting CNI version to %s", minimumCNIVersion) - return minimumCNIVersion, nil + logrus.Infof("Setting CNI version to %s", MinimumCNIVersion) + return MinimumCNIVersion, nil } -func (c *Client) getCRIToolsVersion(packageDef *PackageDefinition) (string, error) { +func (c *Client) GetCRIToolsVersion(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -470,7 +499,7 @@ func (c *Client) getCRIToolsVersion(packageDef *PackageDefinition) (string, erro criToolsVersion := fmt.Sprintf("%s.%s.0", criToolsMajor, criToolsMinor) - releases, err := c.github.Releases("kubernetes-sigs", "cri-tools", false) + releases, err := c.impl.Releases("kubernetes-sigs", "cri-tools", false) if err != nil { return "", err } @@ -506,19 +535,19 @@ func (c *Client) getCRIToolsVersion(packageDef *PackageDefinition) (string, erro return criToolsVersion, nil } -func (c *Client) getDownloadLinkBase(packageDef *PackageDefinition) (string, error) { +func (c *Client) GetDownloadLinkBase(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } if packageDef.Channel == ChannelNightly { - return c.getCIBuildsDownloadLinkBase(packageDef) + return c.GetCIBuildsDownloadLinkBase(packageDef) } - return getDefaultReleaseDownloadLinkBase(packageDef) + return GetDefaultReleaseDownloadLinkBase(packageDef) } -func (c *Client) getCIBuildsDownloadLinkBase(packageDef *PackageDefinition) (string, error) { +func (c *Client) GetCIBuildsDownloadLinkBase(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -526,7 +555,7 @@ func (c *Client) getCIBuildsDownloadLinkBase(packageDef *PackageDefinition) (str ciVersion := packageDef.KubernetesVersion if ciVersion == "" { var err error - ciVersion, err = c.version.GetKubeVersion(release.VersionTypeCILatest) + ciVersion, err = c.impl.GetKubeVersion(release.VersionTypeCILatest) if err != nil { return "", err } @@ -535,7 +564,7 @@ func (c *Client) getCIBuildsDownloadLinkBase(packageDef *PackageDefinition) (str return fmt.Sprintf("https://dl.k8s.io/ci/%s", util.AddTagPrefix(ciVersion)), nil } -func getDefaultReleaseDownloadLinkBase(packageDef *PackageDefinition) (string, error) { +func GetDefaultReleaseDownloadLinkBase(packageDef *PackageDefinition) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -547,7 +576,7 @@ func getDefaultReleaseDownloadLinkBase(packageDef *PackageDefinition) (string, e ), nil } -func getDependencies(packageDef *PackageDefinition) (map[string]string, error) { +func GetDependencies(packageDef *PackageDefinition) (map[string]string, error) { if packageDef == nil { return nil, errors.New("package definition cannot be nil") } @@ -556,11 +585,11 @@ func getDependencies(packageDef *PackageDefinition) (map[string]string, error) { switch packageDef.Name { case "kubelet": - deps["kubernetes-cni"] = minimumCNIVersion + deps["kubernetes-cni"] = MinimumCNIVersion case "kubeadm": deps["kubelet"] = minimumKubernetesVersion deps["kubectl"] = minimumKubernetesVersion - deps["kubernetes-cni"] = minimumCNIVersion + deps["kubernetes-cni"] = MinimumCNIVersion deps["cri-tools"] = minimumCRIToolsVersion } @@ -571,7 +600,7 @@ func getBuildArch(goArch string, buildType options.BuildType) string { return buildArchMap[goArch][buildType] } -func getCNIDownloadLink(packageDef *PackageDefinition, arch string) (string, error) { +func GetCNIDownloadLink(packageDef *PackageDefinition, arch string) (string, error) { if packageDef == nil { return "", errors.New("package definition cannot be nil") } @@ -581,7 +610,7 @@ func getCNIDownloadLink(packageDef *PackageDefinition, arch string) (string, err return "", err } - v075, err := semver.Make(pre117CNIVersion) + v075, err := semver.Make(Pre117CNIVersion) if err != nil { return "", err } diff --git a/pkg/kubepkg/kubepkg_test.go b/pkg/kubepkg/kubepkg_test.go index f5b2854ca1e..2eaf11c70a9 100644 --- a/pkg/kubepkg/kubepkg_test.go +++ b/pkg/kubepkg/kubepkg_test.go @@ -14,29 +14,148 @@ See the License for the specific language governing permissions and limitations under the License. */ -package kubepkg +package kubepkg_test import ( + "io/ioutil" + "os" + "path/filepath" "testing" + "github.com/pkg/errors" "github.com/stretchr/testify/require" - "k8s.io/release/pkg/github/githubfakes" + "k8s.io/release/pkg/kubepkg" + "k8s.io/release/pkg/kubepkg/kubepkgfakes" "k8s.io/release/pkg/kubepkg/options" - "k8s.io/release/pkg/release/releasefakes" ) -func newSUT() *Client { - opts := options.New() - sut := New(opts) +var err = errors.New("") - githubMock := &githubfakes.FakeClient{} - sut.github.SetClient(githubMock) +func newSUT(opts *options.Options) (*kubepkg.Client, *kubepkgfakes.FakeImpl) { + if opts == nil { + opts = options.New() + } + + sut := kubepkg.New(opts) + + implMock := &kubepkgfakes.FakeImpl{} + sut.SetImpl(implMock) + + return sut, implMock +} + +func sutWithTemplateDir( + t *testing.T, opts *options.Options, buildType options.BuildType, +) (sut *kubepkg.Client, cleanup func(), mock *kubepkgfakes.FakeImpl) { + tempDir, err := ioutil.TempDir("", "kubepkg-test-") + require.Nil(t, err) + cleanup = func() { require.Nil(t, os.RemoveAll(tempDir)) } + + if opts == nil { + opts = options.New() + } + opts = opts. + WithTemplateDir(tempDir). + WithBuildType(buildType). + WithKubeVersion("v1.18.0") + sut, mock = newSUT(opts) + + for _, dir := range opts.Packages() { + pkgPath := filepath.Join(tempDir, string(buildType), dir) + require.Nil(t, os.MkdirAll(pkgPath, 0755)) + } + return sut, cleanup, mock +} + +func TestConstructBuilds(t *testing.T) { + sut, cleanup, _ := sutWithTemplateDir(t, nil, options.BuildRpm) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + require.NotEmpty(t, builds) + require.Len(t, builds, 5) + require.Len(t, builds[0].Definitions, 3) + require.Equal(t, "kubelet", builds[0].Package) + require.Equal(t, options.BuildRpm, builds[0].Type) +} + +func TestWalkBuildsSuccessWithoutArchitectures(t *testing.T) { + opts := options.New().WithArchitectures().WithSpecOnly(true) + sut, cleanup, _ := sutWithTemplateDir(t, opts, options.BuildRpm) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + + err = sut.WalkBuilds(builds) + require.Nil(t, err) +} + +func TestWalkBuildsSuccessRPM(t *testing.T) { + sut, cleanup, _ := sutWithTemplateDir(t, nil, options.BuildRpm) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + + err = sut.WalkBuilds(builds) + require.Nil(t, err) +} + +func TestWalkBuildsSuccessRPMSpecOnly(t *testing.T) { + opts := options.New().WithSpecOnly(true) + sut, cleanup, _ := sutWithTemplateDir(t, opts, options.BuildRpm) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + + err = sut.WalkBuilds(builds) + require.Nil(t, err) +} + +func TestWalkBuildsSuccessDeb(t *testing.T) { + sut, cleanup, _ := sutWithTemplateDir(t, nil, options.BuildDeb) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + + err = sut.WalkBuilds(builds) + require.Nil(t, err) +} + +func TestWalkBuildsFailureDebMvFailed(t *testing.T) { + sut, cleanup, mock := sutWithTemplateDir(t, nil, options.BuildDeb) + mock.RunSuccessReturns(err) + defer cleanup() - versionMock := &releasefakes.FakeVersionClient{} - sut.version.SetClient(versionMock) + builds, err := sut.ConstructBuilds() + require.Nil(t, err) - return sut + err = sut.WalkBuilds(builds) + require.NotNil(t, err) +} + +func TestWalkBuildsFailureDebDPKGFailed(t *testing.T) { + sut, cleanup, mock := sutWithTemplateDir(t, nil, options.BuildDeb) + mock.RunSuccessWithWorkDirReturns(err) + defer cleanup() + + builds, err := sut.ConstructBuilds() + require.Nil(t, err) + + err = sut.WalkBuilds(builds) + require.NotNil(t, err) +} + +func TestConstructBuildsFailedInvalidTemplateDir(t *testing.T) { + sut, _ := newSUT(nil) + builds, err := sut.ConstructBuilds() + require.NotNil(t, err) + require.Nil(t, builds) } func TestGetPackageVersionSuccess(t *testing.T) { @@ -76,10 +195,10 @@ func TestGetPackageVersionSuccess(t *testing.T) { }, } - sut := newSUT() + sut, _ := newSUT(nil) for _, tc := range testcases { - actual, err := sut.getPackageVersion( - &PackageDefinition{ + actual, err := sut.GetPackageVersion( + &kubepkg.PackageDefinition{ Name: tc.packageName, Version: tc.version, KubernetesVersion: tc.kubeVersion, @@ -92,8 +211,8 @@ func TestGetPackageVersionSuccess(t *testing.T) { } func TestGetPackageVersionFailure(t *testing.T) { - sut := newSUT() - _, err := sut.getPackageVersion(nil) + sut, _ := newSUT(nil) + _, err := sut.GetPackageVersion(nil) require.NotNil(t, err) } @@ -105,7 +224,7 @@ func TestGetKubernetesVersionSuccess(t *testing.T) { name string version string kubeVersion string - channel ChannelType + channel kubepkg.ChannelType expected string }{ { @@ -115,10 +234,10 @@ func TestGetKubernetesVersionSuccess(t *testing.T) { }, } - sut := newSUT() + sut, _ := newSUT(nil) for _, tc := range testcases { - actual, err := sut.getKubernetesVersion( - &PackageDefinition{ + actual, err := sut.GetKubernetesVersion( + &kubepkg.PackageDefinition{ Version: tc.version, KubernetesVersion: tc.kubeVersion, }, @@ -130,8 +249,8 @@ func TestGetKubernetesVersionSuccess(t *testing.T) { } func TestGetKubernetesVersionFailure(t *testing.T) { - sut := newSUT() - _, err := sut.getKubernetesVersion(nil) + sut, _ := newSUT(nil) + _, err := sut.GetKubernetesVersion(nil) require.NotNil(t, err) } @@ -146,7 +265,7 @@ func TestGetCNIVersionSuccess(t *testing.T) { name: "CNI version supplied, Kubernetes version < 1.17", version: "0.8.3", kubeVersion: "1.16.0", - expected: pre117CNIVersion, + expected: kubepkg.Pre117CNIVersion, }, { name: "CNI version supplied, Kubernetes version >= 1.17", @@ -157,13 +276,13 @@ func TestGetCNIVersionSuccess(t *testing.T) { { name: "CNI version not supplied", kubeVersion: "1.17.0", - expected: minimumCNIVersion, + expected: kubepkg.MinimumCNIVersion, }, } for _, tc := range testcases { - actual, err := getCNIVersion( - &PackageDefinition{ + actual, err := kubepkg.GetCNIVersion( + &kubepkg.PackageDefinition{ Version: tc.version, KubernetesVersion: tc.kubeVersion, }, @@ -175,7 +294,7 @@ func TestGetCNIVersionSuccess(t *testing.T) { } func TestGetCNIVersionFailure(t *testing.T) { - _, err := getCNIVersion(nil) + _, err := kubepkg.GetCNIVersion(nil) require.NotNil(t, err) } @@ -198,10 +317,10 @@ func TestGetCRIToolsVersionSuccess(t *testing.T) { }, } - sut := newSUT() + sut, _ := newSUT(nil) for _, tc := range testcases { - actual, err := sut.getCRIToolsVersion( - &PackageDefinition{ + actual, err := sut.GetCRIToolsVersion( + &kubepkg.PackageDefinition{ Version: tc.version, KubernetesVersion: tc.kubeVersion, }, @@ -213,8 +332,8 @@ func TestGetCRIToolsVersionSuccess(t *testing.T) { } func TestGetCRIToolsVersionFailure(t *testing.T) { - sut := newSUT() - _, err := sut.getCRIToolsVersion(nil) + sut, _ := newSUT(nil) + _, err := sut.GetCRIToolsVersion(nil) require.NotNil(t, err) } @@ -222,13 +341,13 @@ func TestGetDownloadLinkBaseSuccess(t *testing.T) { testcases := []struct { name string kubeVersion string - channel ChannelType + channel kubepkg.ChannelType expected string }{ { name: "CI version", kubeVersion: "1.18.0-alpha.1.277+2099c00290d262", - channel: ChannelNightly, + channel: kubepkg.ChannelNightly, expected: "https://dl.k8s.io/ci/v1.18.0-alpha.1.277+2099c00290d262", }, { @@ -238,10 +357,10 @@ func TestGetDownloadLinkBaseSuccess(t *testing.T) { }, } - sut := newSUT() + sut, _ := newSUT(nil) for _, tc := range testcases { - actual, err := sut.getDownloadLinkBase( - &PackageDefinition{ + actual, err := sut.GetDownloadLinkBase( + &kubepkg.PackageDefinition{ KubernetesVersion: tc.kubeVersion, Channel: tc.channel, }, @@ -253,8 +372,8 @@ func TestGetDownloadLinkBaseSuccess(t *testing.T) { } func TestGetDownloadLinkBaseFailure(t *testing.T) { - sut := newSUT() - _, err := sut.getDownloadLinkBase(nil) + sut, _ := newSUT(nil) + _, err := sut.GetDownloadLinkBase(nil) require.NotNil(t, err) } @@ -271,10 +390,10 @@ func TestGetCIBuildsDownloadLinkBaseSuccess(t *testing.T) { }, } - sut := newSUT() + sut, _ := newSUT(nil) for _, tc := range testcases { - actual, err := sut.getCIBuildsDownloadLinkBase( - &PackageDefinition{ + actual, err := sut.GetCIBuildsDownloadLinkBase( + &kubepkg.PackageDefinition{ KubernetesVersion: tc.kubeVersion, }, ) @@ -285,8 +404,8 @@ func TestGetCIBuildsDownloadLinkBaseSuccess(t *testing.T) { } func TestGetCIBuildsDownloadLinkBaseFailure(t *testing.T) { - sut := newSUT() - _, err := sut.getCIBuildsDownloadLinkBase(nil) + sut, _ := newSUT(nil) + _, err := sut.GetCIBuildsDownloadLinkBase(nil) require.NotNil(t, err) } @@ -309,8 +428,8 @@ func TestGetDefaultReleaseDownloadLinkBaseSuccess(t *testing.T) { } for _, tc := range testcases { - actual, err := getDefaultReleaseDownloadLinkBase( - &PackageDefinition{ + actual, err := kubepkg.GetDefaultReleaseDownloadLinkBase( + &kubepkg.PackageDefinition{ KubernetesVersion: tc.kubeVersion, }, ) @@ -321,7 +440,7 @@ func TestGetDefaultReleaseDownloadLinkBaseSuccess(t *testing.T) { } func TestGetDefaultReleaseDownloadLinkBaseFailure(t *testing.T) { - _, err := getDefaultReleaseDownloadLinkBase(nil) + _, err := kubepkg.GetDefaultReleaseDownloadLinkBase(nil) require.NotNil(t, err) } @@ -351,8 +470,8 @@ func TestGetDependenciesSuccess(t *testing.T) { } for _, tc := range testcases { - actual, err := getDependencies( - &PackageDefinition{ + actual, err := kubepkg.GetDependencies( + &kubepkg.PackageDefinition{ Name: tc.packageName, }, ) @@ -363,7 +482,7 @@ func TestGetDependenciesSuccess(t *testing.T) { } func TestGetDependenciesFailure(t *testing.T) { - _, err := getDependencies(nil) + _, err := kubepkg.GetDependencies(nil) require.NotNil(t, err) } @@ -389,8 +508,8 @@ func TestGetCNIDownloadLinkSuccess(t *testing.T) { } for _, tc := range testcases { - actual, err := getCNIDownloadLink( - &PackageDefinition{ + actual, err := kubepkg.GetCNIDownloadLink( + &kubepkg.PackageDefinition{ Version: tc.version, }, tc.arch, @@ -402,6 +521,6 @@ func TestGetCNIDownloadLinkSuccess(t *testing.T) { } func TestGetCNIDownloadLinkFailure(t *testing.T) { - _, err := getCNIDownloadLink(nil, "amd64") + _, err := kubepkg.GetCNIDownloadLink(nil, "amd64") require.NotNil(t, err) } diff --git a/pkg/kubepkg/kubepkgfakes/BUILD.bazel b/pkg/kubepkg/kubepkgfakes/BUILD.bazel new file mode 100644 index 00000000000..6b0c8abc1b6 --- /dev/null +++ b/pkg/kubepkg/kubepkgfakes/BUILD.bazel @@ -0,0 +1,27 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = ["fake_impl.go"], + importpath = "k8s.io/release/pkg/kubepkg/kubepkgfakes", + visibility = ["//visibility:public"], + deps = [ + "//pkg/kubepkg:go_default_library", + "//pkg/release:go_default_library", + "@com_github_google_go_github_v29//github:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], + visibility = ["//visibility:public"], +) diff --git a/pkg/kubepkg/kubepkgfakes/fake_impl.go b/pkg/kubepkg/kubepkgfakes/fake_impl.go new file mode 100644 index 00000000000..54c76588246 --- /dev/null +++ b/pkg/kubepkg/kubepkgfakes/fake_impl.go @@ -0,0 +1,369 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by counterfeiter. DO NOT EDIT. +package kubepkgfakes + +import ( + "sync" + + "github.com/google/go-github/v29/github" + "k8s.io/release/pkg/kubepkg" + "k8s.io/release/pkg/release" +) + +type FakeImpl struct { + GetKubeVersionStub func(release.VersionType) (string, error) + getKubeVersionMutex sync.RWMutex + getKubeVersionArgsForCall []struct { + arg1 release.VersionType + } + getKubeVersionReturns struct { + result1 string + result2 error + } + getKubeVersionReturnsOnCall map[int]struct { + result1 string + result2 error + } + ReleasesStub func(string, string, bool) ([]*github.RepositoryRelease, error) + releasesMutex sync.RWMutex + releasesArgsForCall []struct { + arg1 string + arg2 string + arg3 bool + } + releasesReturns struct { + result1 []*github.RepositoryRelease + result2 error + } + releasesReturnsOnCall map[int]struct { + result1 []*github.RepositoryRelease + result2 error + } + RunSuccessStub func(string, string, ...string) error + runSuccessMutex sync.RWMutex + runSuccessArgsForCall []struct { + arg1 string + arg2 string + arg3 []string + } + runSuccessReturns struct { + result1 error + } + runSuccessReturnsOnCall map[int]struct { + result1 error + } + RunSuccessWithWorkDirStub func(string, string, ...string) error + runSuccessWithWorkDirMutex sync.RWMutex + runSuccessWithWorkDirArgsForCall []struct { + arg1 string + arg2 string + arg3 []string + } + runSuccessWithWorkDirReturns struct { + result1 error + } + runSuccessWithWorkDirReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeImpl) GetKubeVersion(arg1 release.VersionType) (string, error) { + fake.getKubeVersionMutex.Lock() + ret, specificReturn := fake.getKubeVersionReturnsOnCall[len(fake.getKubeVersionArgsForCall)] + fake.getKubeVersionArgsForCall = append(fake.getKubeVersionArgsForCall, struct { + arg1 release.VersionType + }{arg1}) + fake.recordInvocation("GetKubeVersion", []interface{}{arg1}) + fake.getKubeVersionMutex.Unlock() + if fake.GetKubeVersionStub != nil { + return fake.GetKubeVersionStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getKubeVersionReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeImpl) GetKubeVersionCallCount() int { + fake.getKubeVersionMutex.RLock() + defer fake.getKubeVersionMutex.RUnlock() + return len(fake.getKubeVersionArgsForCall) +} + +func (fake *FakeImpl) GetKubeVersionCalls(stub func(release.VersionType) (string, error)) { + fake.getKubeVersionMutex.Lock() + defer fake.getKubeVersionMutex.Unlock() + fake.GetKubeVersionStub = stub +} + +func (fake *FakeImpl) GetKubeVersionArgsForCall(i int) release.VersionType { + fake.getKubeVersionMutex.RLock() + defer fake.getKubeVersionMutex.RUnlock() + argsForCall := fake.getKubeVersionArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeImpl) GetKubeVersionReturns(result1 string, result2 error) { + fake.getKubeVersionMutex.Lock() + defer fake.getKubeVersionMutex.Unlock() + fake.GetKubeVersionStub = nil + fake.getKubeVersionReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeImpl) GetKubeVersionReturnsOnCall(i int, result1 string, result2 error) { + fake.getKubeVersionMutex.Lock() + defer fake.getKubeVersionMutex.Unlock() + fake.GetKubeVersionStub = nil + if fake.getKubeVersionReturnsOnCall == nil { + fake.getKubeVersionReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getKubeVersionReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeImpl) Releases(arg1 string, arg2 string, arg3 bool) ([]*github.RepositoryRelease, error) { + fake.releasesMutex.Lock() + ret, specificReturn := fake.releasesReturnsOnCall[len(fake.releasesArgsForCall)] + fake.releasesArgsForCall = append(fake.releasesArgsForCall, struct { + arg1 string + arg2 string + arg3 bool + }{arg1, arg2, arg3}) + fake.recordInvocation("Releases", []interface{}{arg1, arg2, arg3}) + fake.releasesMutex.Unlock() + if fake.ReleasesStub != nil { + return fake.ReleasesStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.releasesReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeImpl) ReleasesCallCount() int { + fake.releasesMutex.RLock() + defer fake.releasesMutex.RUnlock() + return len(fake.releasesArgsForCall) +} + +func (fake *FakeImpl) ReleasesCalls(stub func(string, string, bool) ([]*github.RepositoryRelease, error)) { + fake.releasesMutex.Lock() + defer fake.releasesMutex.Unlock() + fake.ReleasesStub = stub +} + +func (fake *FakeImpl) ReleasesArgsForCall(i int) (string, string, bool) { + fake.releasesMutex.RLock() + defer fake.releasesMutex.RUnlock() + argsForCall := fake.releasesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeImpl) ReleasesReturns(result1 []*github.RepositoryRelease, result2 error) { + fake.releasesMutex.Lock() + defer fake.releasesMutex.Unlock() + fake.ReleasesStub = nil + fake.releasesReturns = struct { + result1 []*github.RepositoryRelease + result2 error + }{result1, result2} +} + +func (fake *FakeImpl) ReleasesReturnsOnCall(i int, result1 []*github.RepositoryRelease, result2 error) { + fake.releasesMutex.Lock() + defer fake.releasesMutex.Unlock() + fake.ReleasesStub = nil + if fake.releasesReturnsOnCall == nil { + fake.releasesReturnsOnCall = make(map[int]struct { + result1 []*github.RepositoryRelease + result2 error + }) + } + fake.releasesReturnsOnCall[i] = struct { + result1 []*github.RepositoryRelease + result2 error + }{result1, result2} +} + +func (fake *FakeImpl) RunSuccess(arg1 string, arg2 string, arg3 ...string) error { + fake.runSuccessMutex.Lock() + ret, specificReturn := fake.runSuccessReturnsOnCall[len(fake.runSuccessArgsForCall)] + fake.runSuccessArgsForCall = append(fake.runSuccessArgsForCall, struct { + arg1 string + arg2 string + arg3 []string + }{arg1, arg2, arg3}) + fake.recordInvocation("RunSuccess", []interface{}{arg1, arg2, arg3}) + fake.runSuccessMutex.Unlock() + if fake.RunSuccessStub != nil { + return fake.RunSuccessStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.runSuccessReturns + return fakeReturns.result1 +} + +func (fake *FakeImpl) RunSuccessCallCount() int { + fake.runSuccessMutex.RLock() + defer fake.runSuccessMutex.RUnlock() + return len(fake.runSuccessArgsForCall) +} + +func (fake *FakeImpl) RunSuccessCalls(stub func(string, string, ...string) error) { + fake.runSuccessMutex.Lock() + defer fake.runSuccessMutex.Unlock() + fake.RunSuccessStub = stub +} + +func (fake *FakeImpl) RunSuccessArgsForCall(i int) (string, string, []string) { + fake.runSuccessMutex.RLock() + defer fake.runSuccessMutex.RUnlock() + argsForCall := fake.runSuccessArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeImpl) RunSuccessReturns(result1 error) { + fake.runSuccessMutex.Lock() + defer fake.runSuccessMutex.Unlock() + fake.RunSuccessStub = nil + fake.runSuccessReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeImpl) RunSuccessReturnsOnCall(i int, result1 error) { + fake.runSuccessMutex.Lock() + defer fake.runSuccessMutex.Unlock() + fake.RunSuccessStub = nil + if fake.runSuccessReturnsOnCall == nil { + fake.runSuccessReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.runSuccessReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeImpl) RunSuccessWithWorkDir(arg1 string, arg2 string, arg3 ...string) error { + fake.runSuccessWithWorkDirMutex.Lock() + ret, specificReturn := fake.runSuccessWithWorkDirReturnsOnCall[len(fake.runSuccessWithWorkDirArgsForCall)] + fake.runSuccessWithWorkDirArgsForCall = append(fake.runSuccessWithWorkDirArgsForCall, struct { + arg1 string + arg2 string + arg3 []string + }{arg1, arg2, arg3}) + fake.recordInvocation("RunSuccessWithWorkDir", []interface{}{arg1, arg2, arg3}) + fake.runSuccessWithWorkDirMutex.Unlock() + if fake.RunSuccessWithWorkDirStub != nil { + return fake.RunSuccessWithWorkDirStub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.runSuccessWithWorkDirReturns + return fakeReturns.result1 +} + +func (fake *FakeImpl) RunSuccessWithWorkDirCallCount() int { + fake.runSuccessWithWorkDirMutex.RLock() + defer fake.runSuccessWithWorkDirMutex.RUnlock() + return len(fake.runSuccessWithWorkDirArgsForCall) +} + +func (fake *FakeImpl) RunSuccessWithWorkDirCalls(stub func(string, string, ...string) error) { + fake.runSuccessWithWorkDirMutex.Lock() + defer fake.runSuccessWithWorkDirMutex.Unlock() + fake.RunSuccessWithWorkDirStub = stub +} + +func (fake *FakeImpl) RunSuccessWithWorkDirArgsForCall(i int) (string, string, []string) { + fake.runSuccessWithWorkDirMutex.RLock() + defer fake.runSuccessWithWorkDirMutex.RUnlock() + argsForCall := fake.runSuccessWithWorkDirArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeImpl) RunSuccessWithWorkDirReturns(result1 error) { + fake.runSuccessWithWorkDirMutex.Lock() + defer fake.runSuccessWithWorkDirMutex.Unlock() + fake.RunSuccessWithWorkDirStub = nil + fake.runSuccessWithWorkDirReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeImpl) RunSuccessWithWorkDirReturnsOnCall(i int, result1 error) { + fake.runSuccessWithWorkDirMutex.Lock() + defer fake.runSuccessWithWorkDirMutex.Unlock() + fake.RunSuccessWithWorkDirStub = nil + if fake.runSuccessWithWorkDirReturnsOnCall == nil { + fake.runSuccessWithWorkDirReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.runSuccessWithWorkDirReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeImpl) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getKubeVersionMutex.RLock() + defer fake.getKubeVersionMutex.RUnlock() + fake.releasesMutex.RLock() + defer fake.releasesMutex.RUnlock() + fake.runSuccessMutex.RLock() + defer fake.runSuccessMutex.RUnlock() + fake.runSuccessWithWorkDirMutex.RLock() + defer fake.runSuccessWithWorkDirMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeImpl) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ kubepkg.Impl = new(FakeImpl)