github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/cmd/juju/machine/upgradeseries_test.go (about)

     1  // Copyright 2018 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package machine_test
     5  
     6  import (
     7  	"bytes"
     8  	"fmt"
     9  	"strings"
    10  
    11  	"github.com/golang/mock/gomock"
    12  	"github.com/juju/cmd"
    13  	"github.com/juju/cmd/cmdtesting"
    14  	jc "github.com/juju/testing/checkers"
    15  	gc "gopkg.in/check.v1"
    16  
    17  	"github.com/juju/juju/cmd/juju/machine"
    18  	"github.com/juju/juju/cmd/juju/machine/mocks"
    19  	"github.com/juju/juju/testing"
    20  )
    21  
    22  type UpgradeSeriesSuite struct {
    23  	testing.BaseSuite
    24  
    25  	prepareExpectation  *upgradeSeriesPrepareExpectation
    26  	completeExpectation *upgradeSeriesCompleteExpectation
    27  }
    28  
    29  var _ = gc.Suite(&UpgradeSeriesSuite{})
    30  
    31  func (s *UpgradeSeriesSuite) SetUpTest(c *gc.C) {
    32  	s.BaseSuite.SetUpTest(c)
    33  	s.prepareExpectation = &upgradeSeriesPrepareExpectation{gomock.Any(), gomock.Any(), gomock.Any()}
    34  	s.completeExpectation = &upgradeSeriesCompleteExpectation{gomock.Any()}
    35  }
    36  
    37  const machineArg = "1"
    38  const seriesArg = "xenial"
    39  
    40  var units = []string{"bar/0", "foo/0"}
    41  
    42  func (s *UpgradeSeriesSuite) runUpgradeSeriesCommand(c *gc.C, args ...string) error {
    43  	_, err := s.runUpgradeSeriesCommandWithConfirmation(c, "y", args...)
    44  	return err
    45  }
    46  
    47  func (s *UpgradeSeriesSuite) runUpgradeSeriesCommandWithConfirmation(
    48  	c *gc.C, confirmation string, args ...string,
    49  ) (*cmd.Context, error) {
    50  	var stdin, stdout, stderr bytes.Buffer
    51  	ctx, err := cmd.DefaultContext()
    52  	c.Assert(err, jc.ErrorIsNil)
    53  	ctx.Stderr = &stderr
    54  	ctx.Stdout = &stdout
    55  	ctx.Stdin = &stdin
    56  	stdin.WriteString(confirmation)
    57  
    58  	mockController := gomock.NewController(c)
    59  	defer mockController.Finish()
    60  
    61  	mockUpgradeSeriesAPI := mocks.NewMockUpgradeMachineSeriesAPI(mockController)
    62  
    63  	uExp := mockUpgradeSeriesAPI.EXPECT()
    64  	prep := s.prepareExpectation
    65  	uExp.UpgradeSeriesValidate(prep.machineArg, prep.seriesArg).AnyTimes().Return(units, nil)
    66  	uExp.UpgradeSeriesPrepare(prep.machineArg, prep.seriesArg, prep.force).AnyTimes()
    67  	uExp.UpgradeSeriesComplete(s.completeExpectation.machineNumber).AnyTimes()
    68  
    69  	com := machine.NewUpgradeSeriesCommandForTest(mockUpgradeSeriesAPI)
    70  
    71  	err = cmdtesting.InitCommand(com, args)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  	err = com.Run(ctx)
    76  	if err != nil {
    77  		return nil, err
    78  	}
    79  	return ctx, nil
    80  }
    81  
    82  func (s *UpgradeSeriesSuite) TestPrepareCommand(c *gc.C) {
    83  	s.prepareExpectation = &upgradeSeriesPrepareExpectation{machineArg, seriesArg, gomock.Eq(false)}
    84  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, seriesArg)
    85  	c.Assert(err, jc.ErrorIsNil)
    86  }
    87  
    88  func (s *UpgradeSeriesSuite) TestTooFewArgs(c *gc.C) {
    89  	err := s.runUpgradeSeriesCommand(c, machineArg)
    90  	c.Assert(err, gc.ErrorMatches, "wrong number of arguments")
    91  }
    92  
    93  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldAcceptForceOption(c *gc.C) {
    94  	s.prepareExpectation = &upgradeSeriesPrepareExpectation{machineArg, seriesArg, gomock.Eq(true)}
    95  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, seriesArg, "--force")
    96  	c.Assert(err, jc.ErrorIsNil)
    97  }
    98  
    99  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldAbortOnFailedConfirmation(c *gc.C) {
   100  	_, err := s.runUpgradeSeriesCommandWithConfirmation(c, "n", machineArg, machine.PrepareCommand, seriesArg)
   101  	c.Assert(err, gc.ErrorMatches, "upgrade series: aborted")
   102  }
   103  
   104  func (s *UpgradeSeriesSuite) TestUpgradeCommandShouldNotAcceptInvalidPrepCommands(c *gc.C) {
   105  	invalidPrepCommand := "actuate"
   106  	err := s.runUpgradeSeriesCommand(c, machineArg, invalidPrepCommand, seriesArg)
   107  	c.Assert(err, gc.ErrorMatches,
   108  		".* \"actuate\" is an invalid upgrade-series command; valid commands are: prepare, complete.")
   109  }
   110  
   111  func (s *UpgradeSeriesSuite) TestUpgradeCommandShouldNotAcceptInvalidMachineArgs(c *gc.C) {
   112  	invalidMachineArg := "machine5"
   113  	err := s.runUpgradeSeriesCommand(c, invalidMachineArg, machine.PrepareCommand, seriesArg)
   114  	c.Assert(err, gc.ErrorMatches, "\"machine5\" is an invalid machine name")
   115  }
   116  
   117  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldOnlyAcceptSupportedSeries(c *gc.C) {
   118  	BadSeries := "Combative Caribou"
   119  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, BadSeries)
   120  	c.Assert(err, gc.ErrorMatches, ".* is an unsupported series")
   121  }
   122  
   123  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldSupportSeriesRegardlessOfCase(c *gc.C) {
   124  	capitalizedCaseXenial := "Xenial"
   125  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, capitalizedCaseXenial)
   126  	c.Assert(err, jc.ErrorIsNil)
   127  }
   128  
   129  func (s *UpgradeSeriesSuite) TestCompleteCommand(c *gc.C) {
   130  	s.completeExpectation.machineNumber = machineArg
   131  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.CompleteCommand)
   132  	c.Assert(err, jc.ErrorIsNil)
   133  }
   134  
   135  func (s *UpgradeSeriesSuite) TestCompleteCommandDoesNotAcceptSeries(c *gc.C) {
   136  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.CompleteCommand, seriesArg)
   137  	c.Assert(err, gc.ErrorMatches, "wrong number of arguments")
   138  }
   139  
   140  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldAcceptYes(c *gc.C) {
   141  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, seriesArg, "--yes")
   142  	c.Assert(err, jc.ErrorIsNil)
   143  }
   144  
   145  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldAcceptYesAbbreviation(c *gc.C) {
   146  	err := s.runUpgradeSeriesCommand(c, machineArg, machine.PrepareCommand, seriesArg, "-y")
   147  	c.Assert(err, jc.ErrorIsNil)
   148  }
   149  
   150  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldPromptUserForConfirmation(c *gc.C) {
   151  	ctx, err := s.runUpgradeSeriesCommandWithConfirmation(c, "y", machineArg, machine.PrepareCommand, seriesArg)
   152  	c.Assert(err, jc.ErrorIsNil)
   153  	c.Assert(ctx.Stdout.(*bytes.Buffer).String(), jc.HasSuffix, "Continue [y/N]?")
   154  }
   155  
   156  func (s *UpgradeSeriesSuite) TestPrepareCommandShouldAcceptYesFlagAndNotPrompt(c *gc.C) {
   157  	ctx, err := s.runUpgradeSeriesCommandWithConfirmation(c, "n", machineArg, machine.PrepareCommand, seriesArg, "-y")
   158  	c.Assert(err, jc.ErrorIsNil)
   159  
   160  	//There is no confirmation message since the `-y/--yes` flag is being used to avoid the prompt.
   161  	confirmationMessage := ""
   162  
   163  	finishedMessage := fmt.Sprintf(machine.UpgradeSeriesPrepareFinishedMessage, machineArg)
   164  	displayedMessage := strings.Join([]string{confirmationMessage, finishedMessage}, "") + "\n"
   165  	out := ctx.Stderr.(*bytes.Buffer).String()
   166  	c.Assert(out, gc.Equals, displayedMessage)
   167  	c.Assert(out, jc.Contains, fmt.Sprintf("juju upgrade-series %s complete", machineArg))
   168  }
   169  
   170  type upgradeSeriesPrepareExpectation struct {
   171  	machineArg, seriesArg, force interface{}
   172  }
   173  
   174  type upgradeSeriesCompleteExpectation struct {
   175  	machineNumber interface{}
   176  }