github.com/cloudfoundry-incubator/stembuild@v0.0.0-20211223202937-5b61d62226c6/commandparser/package_stemcell_test.go (about)

     1  package commandparser_test
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"flag"
     7  
     8  	"github.com/google/subcommands"
     9  
    10  	"github.com/cloudfoundry-incubator/stembuild/commandparser/commandparserfakes"
    11  
    12  	"github.com/cloudfoundry-incubator/stembuild/commandparser"
    13  	. "github.com/onsi/ginkgo"
    14  	. "github.com/onsi/gomega"
    15  )
    16  
    17  var _ = Describe("package_stemcell", func() {
    18  	// Focus of this test is not to test the Flags.Parse functionality as much
    19  	// as to test that the command line flags values are stored in the expected
    20  	// struct variables. This adds a bit of protection when renaming flag parameters.
    21  	Describe("SetFlags", func() {
    22  
    23  		var (
    24  			f      *flag.FlagSet
    25  			PkgCmd *commandparser.PackageCmd
    26  
    27  			oSAndVersionGetter *commandparserfakes.FakeOSAndVersionGetter
    28  			packagerFactory    *commandparserfakes.FakePackagerFactory
    29  			packager           *commandparserfakes.FakePackager
    30  			packagerMessenger  *commandparserfakes.FakePackagerMessenger
    31  		)
    32  
    33  		BeforeEach(func() {
    34  			f = flag.NewFlagSet("test", flag.ContinueOnError)
    35  
    36  			oSAndVersionGetter = new(commandparserfakes.FakeOSAndVersionGetter)
    37  			packagerFactory = new(commandparserfakes.FakePackagerFactory)
    38  			packager = new(commandparserfakes.FakePackager)
    39  			packagerMessenger = new(commandparserfakes.FakePackagerMessenger)
    40  
    41  			packagerFactory.PackagerReturns(packager, nil)
    42  
    43  			PkgCmd = commandparser.NewPackageCommand(oSAndVersionGetter, packagerFactory, packagerMessenger)
    44  			PkgCmd.SetFlags(f)
    45  			PkgCmd.GlobalFlags = &commandparser.GlobalFlags{false, false, false}
    46  		})
    47  
    48  		var defaultArgs = []string{}
    49  
    50  		Describe("Execute", func() {
    51  			BeforeEach(func() {
    52  				oSAndVersionGetter.GetVersionReturns("2019.2")
    53  				oSAndVersionGetter.GetOsReturns("2019")
    54  			})
    55  
    56  			It("packager is instantiated with expected vmdk source config", func() {
    57  				vmdk_args := []string{"-vmdk", "some_vmdk_file"}
    58  
    59  				err := f.Parse(vmdk_args)
    60  				Expect(err).ToNot(HaveOccurred())
    61  
    62  				exitStatus := PkgCmd.Execute(context.Background(), f)
    63  				Expect(exitStatus).To(Equal(subcommands.ExitSuccess))
    64  
    65  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
    66  				actualSourceConfig, _, _, _ := packagerFactory.PackagerArgsForCall(0)
    67  				Expect(actualSourceConfig.Vmdk).To(Equal("some_vmdk_file"))
    68  			})
    69  
    70  			It("packager is instantiated with expected vcenter source config", func() {
    71  				vcenter_args := []string{
    72  					"-vcenter-url", "https://vcenter.test",
    73  					"-vcenter-username", "test-user",
    74  					"-vcenter-password", "verysecure",
    75  					"-vcenter-ca-certs", "/path/to/cert/file",
    76  					"-vm-inventory-path", "/path/to/vm",
    77  				}
    78  
    79  				err := f.Parse(vcenter_args)
    80  				Expect(err).ToNot(HaveOccurred())
    81  
    82  				exitStatus := PkgCmd.Execute(context.Background(), f)
    83  				Expect(exitStatus).To(Equal(subcommands.ExitSuccess))
    84  
    85  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
    86  				actualSourceConfig, _, _, _ := packagerFactory.PackagerArgsForCall(0)
    87  				Expect(actualSourceConfig.URL).To(Equal("https://vcenter.test"))
    88  				Expect(actualSourceConfig.Username).To(Equal("test-user"))
    89  				Expect(actualSourceConfig.Password).To(Equal("verysecure"))
    90  				Expect(actualSourceConfig.VmInventoryPath).To(Equal("/path/to/vm"))
    91  				Expect(actualSourceConfig.CaCertFile).To(Equal("/path/to/cert/file"))
    92  			})
    93  
    94  			It("packager is instantiated with expected output config directory when using long form -outputdir", func() {
    95  				longformOutputDirArgs := []string{"-outputDir", "some_output_dir"}
    96  
    97  				err := f.Parse(longformOutputDirArgs)
    98  				Expect(err).ToNot(HaveOccurred())
    99  
   100  				exitStatus := PkgCmd.Execute(context.Background(), f)
   101  				Expect(exitStatus).To(Equal(subcommands.ExitSuccess))
   102  
   103  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
   104  				_, actualOutputConfig, _, _ := packagerFactory.PackagerArgsForCall(0)
   105  				Expect(actualOutputConfig.OutputDir).To(Equal("some_output_dir"))
   106  			})
   107  
   108  			It("packager is instantiated with expected output config when using short form -o", func() {
   109  				shortformOutputDirArgs := []string{"-o", "some_output_dir"}
   110  
   111  				err := f.Parse(shortformOutputDirArgs)
   112  				Expect(err).ToNot(HaveOccurred())
   113  
   114  				exitStatus := PkgCmd.Execute(context.Background(), f)
   115  				Expect(exitStatus).To(Equal(subcommands.ExitSuccess))
   116  
   117  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
   118  				_, actualOutputConfig, _, _ := packagerFactory.PackagerArgsForCall(0)
   119  				Expect(actualOutputConfig.OutputDir).To(Equal("some_output_dir"))
   120  				Expect(actualOutputConfig.StemcellVersion).To(Equal("2019.2"))
   121  				Expect(actualOutputConfig.Os).To(Equal("2019"))
   122  			})
   123  
   124  			It("creates packager with correct stemcell patch version number when argument provided", func() {
   125  				oSAndVersionGetter.GetVersionWithPatchNumberReturns("1803.27.36")
   126  
   127  				args := append(defaultArgs, "-patch-version", "36")
   128  
   129  				err := f.Parse(args)
   130  				Expect(err).ToNot(HaveOccurred())
   131  
   132  				exitStatus := PkgCmd.Execute(context.Background(), f)
   133  				Expect(exitStatus).To(Equal(subcommands.ExitSuccess))
   134  
   135  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
   136  				_, actualOutputConfig, _, _ := packagerFactory.PackagerArgsForCall(0)
   137  				Expect(actualOutputConfig.StemcellVersion).To(Equal("1803.27.36"))
   138  
   139  				Expect(oSAndVersionGetter.GetVersionWithPatchNumberCallCount()).To(Equal(1))
   140  				actualPatchVersion := oSAndVersionGetter.GetVersionWithPatchNumberArgsForCall(0)
   141  				Expect(actualPatchVersion).To(Equal("36"))
   142  			})
   143  
   144  			It("package is not called if the OS is invalid", func() {
   145  				oSAndVersionGetter.GetOsReturns("2017")
   146  
   147  				err := f.Parse(defaultArgs)
   148  				Expect(err).ToNot(HaveOccurred())
   149  
   150  				exitStatus := PkgCmd.Execute(context.Background(), f)
   151  				Expect(exitStatus).To(Equal(subcommands.ExitFailure))
   152  
   153  				Expect(packager.PackageCallCount()).To(Equal(0))
   154  
   155  				Expect(packagerMessenger.InvalidOutputConfigCallCount()).To(Equal(1))
   156  				receivedError := packagerMessenger.InvalidOutputConfigArgsForCall(0)
   157  				Expect(receivedError.Error()).To(MatchRegexp("2017"))
   158  			})
   159  
   160  			It("package is not called if the packager factory returns an error", func() {
   161  				packagerFactory.PackagerReturns(nil, errors.New("Couldn't make a packager!"))
   162  
   163  				err := f.Parse(defaultArgs)
   164  				Expect(err).ToNot(HaveOccurred())
   165  
   166  				exitStatus := PkgCmd.Execute(context.Background(), f)
   167  				Expect(exitStatus).To(Equal(subcommands.ExitFailure))
   168  
   169  				Expect(packagerFactory.PackagerCallCount()).To(Equal(1))
   170  				Expect(packager.PackageCallCount()).To(Equal(0))
   171  
   172  				Expect(packagerMessenger.CannotCreatePackagerCallCount()).To(Equal(1))
   173  				receivedError := packagerMessenger.CannotCreatePackagerArgsForCall(0)
   174  				Expect(receivedError).To(MatchError("Couldn't make a packager!"))
   175  			})
   176  
   177  			It("package is not called if there is no free space", func() {
   178  				packager.ValidateFreeSpaceForPackageReturns(errors.New("No space!"))
   179  
   180  				err := f.Parse(defaultArgs)
   181  				Expect(err).ToNot(HaveOccurred())
   182  
   183  				exitStatus := PkgCmd.Execute(context.Background(), f)
   184  				Expect(exitStatus).To(Equal(subcommands.ExitFailure))
   185  
   186  				Expect(packager.ValidateFreeSpaceForPackageCallCount()).To(Equal(1))
   187  				Expect(packager.PackageCallCount()).To(Equal(0))
   188  
   189  				Expect(packagerMessenger.DoesNotHaveEnoughSpaceCallCount()).To(Equal(1))
   190  				receivedError := packagerMessenger.DoesNotHaveEnoughSpaceArgsForCall(0)
   191  				Expect(receivedError).To(MatchError("No space!"))
   192  			})
   193  
   194  			It("package is not called if source parameters are not valid", func() {
   195  				packager.ValidateSourceParametersReturns(errors.New("invalid source parameters"))
   196  
   197  				err := f.Parse(defaultArgs)
   198  				Expect(err).ToNot(HaveOccurred())
   199  
   200  				exitStatus := PkgCmd.Execute(context.Background(), f)
   201  				Expect(exitStatus).To(Equal(subcommands.ExitFailure))
   202  
   203  				Expect(packager.ValidateSourceParametersCallCount()).To(Equal(1))
   204  				Expect(packager.PackageCallCount()).To(Equal(0))
   205  
   206  				Expect(packagerMessenger.SourceParametersAreInvalidCallCount()).To(Equal(1))
   207  				receivedError := packagerMessenger.SourceParametersAreInvalidArgsForCall(0)
   208  				Expect(receivedError).To(MatchError("invalid source parameters"))
   209  			})
   210  
   211  			It("exits with failure if package returns an error", func() {
   212  				packager.PackageReturns(errors.New("Didn't make it"))
   213  
   214  				err := f.Parse(defaultArgs)
   215  				Expect(err).ToNot(HaveOccurred())
   216  
   217  				exitStatus := PkgCmd.Execute(context.Background(), f)
   218  				Expect(exitStatus).To(Equal(subcommands.ExitFailure))
   219  
   220  				Expect(packager.PackageCallCount()).To(Equal(1))
   221  
   222  				Expect(packagerMessenger.PackageFailedCallCount()).To(Equal(1))
   223  				receivedError := packagerMessenger.PackageFailedArgsForCall(0)
   224  				Expect(receivedError).To(MatchError("Didn't make it"))
   225  			})
   226  		})
   227  	})
   228  })