github.com/cloudfoundry-attic/cli-with-i18n@v6.32.1-0.20171002233121-7401370d3b85+incompatible/command/v3/run_task_command_test.go (about)

     1  package v3_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	"code.cloudfoundry.org/cli/actor/sharedaction"
     7  	"code.cloudfoundry.org/cli/actor/v3action"
     8  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
     9  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccversion"
    10  	"code.cloudfoundry.org/cli/command/commandfakes"
    11  	"code.cloudfoundry.org/cli/command/flag"
    12  	"code.cloudfoundry.org/cli/command/translatableerror"
    13  	"code.cloudfoundry.org/cli/command/v3"
    14  	"code.cloudfoundry.org/cli/command/v3/v3fakes"
    15  	"code.cloudfoundry.org/cli/types"
    16  	"code.cloudfoundry.org/cli/util/configv3"
    17  	"code.cloudfoundry.org/cli/util/ui"
    18  	. "github.com/onsi/ginkgo"
    19  	. "github.com/onsi/gomega"
    20  	. "github.com/onsi/gomega/gbytes"
    21  )
    22  
    23  var _ = Describe("run-task Command", func() {
    24  	var (
    25  		cmd             v3.RunTaskCommand
    26  		testUI          *ui.UI
    27  		fakeConfig      *commandfakes.FakeConfig
    28  		fakeSharedActor *commandfakes.FakeSharedActor
    29  		fakeActor       *v3fakes.FakeRunTaskActor
    30  		binaryName      string
    31  		executeErr      error
    32  	)
    33  
    34  	BeforeEach(func() {
    35  		testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer())
    36  		fakeConfig = new(commandfakes.FakeConfig)
    37  		fakeSharedActor = new(commandfakes.FakeSharedActor)
    38  		fakeActor = new(v3fakes.FakeRunTaskActor)
    39  
    40  		cmd = v3.RunTaskCommand{
    41  			UI:          testUI,
    42  			Config:      fakeConfig,
    43  			SharedActor: fakeSharedActor,
    44  			Actor:       fakeActor,
    45  		}
    46  
    47  		cmd.RequiredArgs.AppName = "some-app-name"
    48  		cmd.RequiredArgs.Command = "some command"
    49  
    50  		binaryName = "faceman"
    51  		fakeConfig.BinaryNameReturns(binaryName)
    52  		fakeActor.CloudControllerAPIVersionReturns(ccversion.MinVersionRunTaskV3)
    53  	})
    54  
    55  	JustBeforeEach(func() {
    56  		executeErr = cmd.Execute(nil)
    57  	})
    58  
    59  	Context("when the API version is below the minimum", func() {
    60  		BeforeEach(func() {
    61  			fakeActor.CloudControllerAPIVersionReturns("0.0.0")
    62  		})
    63  
    64  		It("returns a MinimumAPIVersionNotMetError", func() {
    65  			Expect(executeErr).To(MatchError(translatableerror.MinimumAPIVersionNotMetError{
    66  				CurrentVersion: "0.0.0",
    67  				MinimumVersion: ccversion.MinVersionRunTaskV3,
    68  			}))
    69  		})
    70  	})
    71  
    72  	Context("when checking target fails", func() {
    73  		BeforeEach(func() {
    74  			fakeSharedActor.CheckTargetReturns(sharedaction.NotLoggedInError{BinaryName: binaryName})
    75  		})
    76  
    77  		It("returns an error", func() {
    78  			Expect(executeErr).To(MatchError(translatableerror.NotLoggedInError{BinaryName: binaryName}))
    79  
    80  			Expect(fakeSharedActor.CheckTargetCallCount()).To(Equal(1))
    81  			_, checkTargetedOrg, checkTargetedSpace := fakeSharedActor.CheckTargetArgsForCall(0)
    82  			Expect(checkTargetedOrg).To(BeTrue())
    83  			Expect(checkTargetedSpace).To(BeTrue())
    84  		})
    85  	})
    86  
    87  	Context("when the user is logged in, and a space and org are targeted", func() {
    88  		BeforeEach(func() {
    89  			fakeConfig.HasTargetedOrganizationReturns(true)
    90  			fakeConfig.TargetedOrganizationReturns(configv3.Organization{
    91  				GUID: "some-org-guid",
    92  				Name: "some-org",
    93  			})
    94  			fakeConfig.HasTargetedSpaceReturns(true)
    95  			fakeConfig.TargetedSpaceReturns(configv3.Space{
    96  				GUID: "some-space-guid",
    97  				Name: "some-space",
    98  			})
    99  		})
   100  
   101  		Context("when getting the current user returns an error", func() {
   102  			var expectedErr error
   103  
   104  			BeforeEach(func() {
   105  				expectedErr = errors.New("got bananapants??")
   106  				fakeConfig.CurrentUserReturns(
   107  					configv3.User{},
   108  					expectedErr)
   109  			})
   110  
   111  			It("returns the error", func() {
   112  				Expect(executeErr).To(MatchError(expectedErr))
   113  			})
   114  		})
   115  
   116  		Context("when getting the current user does not return an error", func() {
   117  			BeforeEach(func() {
   118  				fakeConfig.CurrentUserReturns(
   119  					configv3.User{Name: "some-user"},
   120  					nil)
   121  			})
   122  
   123  			Context("when provided a valid application name", func() {
   124  				BeforeEach(func() {
   125  					fakeActor.GetApplicationByNameAndSpaceReturns(
   126  						v3action.Application{GUID: "some-app-guid"},
   127  						v3action.Warnings{"get-application-warning-1", "get-application-warning-2"},
   128  						nil)
   129  				})
   130  
   131  				Context("when the task name is not provided", func() {
   132  					BeforeEach(func() {
   133  						fakeActor.RunTaskReturns(
   134  							v3action.Task{
   135  								Name:       "31337ddd",
   136  								SequenceID: 3,
   137  							},
   138  							v3action.Warnings{"get-application-warning-3"},
   139  							nil)
   140  					})
   141  
   142  					It("creates a new task and displays all warnings", func() {
   143  						Expect(executeErr).ToNot(HaveOccurred())
   144  
   145  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   146  						appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   147  						Expect(appName).To(Equal("some-app-name"))
   148  						Expect(spaceGUID).To(Equal("some-space-guid"))
   149  
   150  						Expect(fakeActor.RunTaskCallCount()).To(Equal(1))
   151  						appGUID, task := fakeActor.RunTaskArgsForCall(0)
   152  						Expect(appGUID).To(Equal("some-app-guid"))
   153  						Expect(task).To(Equal(v3action.Task{Command: "some command"}))
   154  
   155  						Expect(testUI.Out).To(Say(`Creating task for app some-app-name in org some-org / space some-space as some-user...
   156  OK
   157  
   158  Task has been submitted successfully for execution.
   159  task name:   31337ddd
   160  task id:     3
   161  `))
   162  						Expect(testUI.Err).To(Say(`get-application-warning-1
   163  get-application-warning-2
   164  get-application-warning-3`))
   165  					})
   166  				})
   167  
   168  				Context("when the task name is provided", func() {
   169  					BeforeEach(func() {
   170  						cmd.Name = "some-task-name"
   171  						fakeActor.RunTaskReturns(
   172  							v3action.Task{
   173  								Name:       "some-task-name",
   174  								SequenceID: 3,
   175  							},
   176  							v3action.Warnings{"get-application-warning-3"},
   177  							nil)
   178  					})
   179  
   180  					It("creates a new task and outputs all warnings", func() {
   181  						Expect(executeErr).ToNot(HaveOccurred())
   182  
   183  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   184  						appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   185  						Expect(appName).To(Equal("some-app-name"))
   186  						Expect(spaceGUID).To(Equal("some-space-guid"))
   187  
   188  						Expect(fakeActor.RunTaskCallCount()).To(Equal(1))
   189  						appGUID, task := fakeActor.RunTaskArgsForCall(0)
   190  						Expect(appGUID).To(Equal("some-app-guid"))
   191  						Expect(task).To(Equal(v3action.Task{Command: "some command", Name: "some-task-name"}))
   192  
   193  						Expect(testUI.Out).To(Say(`Creating task for app some-app-name in org some-org / space some-space as some-user...
   194  OK
   195  
   196  Task has been submitted successfully for execution.
   197  task name:   some-task-name
   198  task id:     3`,
   199  						))
   200  						Expect(testUI.Err).To(Say(`get-application-warning-1
   201  get-application-warning-2
   202  get-application-warning-3`))
   203  					})
   204  				})
   205  
   206  				Context("when task disk space is provided", func() {
   207  					BeforeEach(func() {
   208  						cmd.Name = "some-task-name"
   209  						cmd.Disk = flag.Megabytes{NullUint64: types.NullUint64{Value: 321, IsSet: true}}
   210  						fakeActor.RunTaskReturns(
   211  							v3action.Task{
   212  								Name:       "some-task-name",
   213  								SequenceID: 3,
   214  							},
   215  							v3action.Warnings{"get-application-warning-3"},
   216  							nil)
   217  					})
   218  
   219  					It("creates a new task and outputs all warnings", func() {
   220  						Expect(executeErr).ToNot(HaveOccurred())
   221  
   222  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   223  						appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   224  						Expect(appName).To(Equal("some-app-name"))
   225  						Expect(spaceGUID).To(Equal("some-space-guid"))
   226  
   227  						Expect(fakeActor.RunTaskCallCount()).To(Equal(1))
   228  						appGUID, task := fakeActor.RunTaskArgsForCall(0)
   229  						Expect(appGUID).To(Equal("some-app-guid"))
   230  						Expect(task).To(Equal(v3action.Task{
   231  							Command:  "some command",
   232  							Name:     "some-task-name",
   233  							DiskInMB: 321,
   234  						}))
   235  
   236  						Expect(testUI.Out).To(Say(`Creating task for app some-app-name in org some-org / space some-space as some-user...
   237  OK
   238  
   239  Task has been submitted successfully for execution.
   240  task name:   some-task-name
   241  task id:     3`,
   242  						))
   243  						Expect(testUI.Err).To(Say(`get-application-warning-1
   244  get-application-warning-2
   245  get-application-warning-3`))
   246  					})
   247  				})
   248  
   249  				Context("when task memory is provided", func() {
   250  					BeforeEach(func() {
   251  						cmd.Name = "some-task-name"
   252  						cmd.Memory = flag.Megabytes{NullUint64: types.NullUint64{Value: 123, IsSet: true}}
   253  						fakeActor.RunTaskReturns(
   254  							v3action.Task{
   255  								Name:       "some-task-name",
   256  								SequenceID: 3,
   257  							},
   258  							v3action.Warnings{"get-application-warning-3"},
   259  							nil)
   260  					})
   261  
   262  					It("creates a new task and outputs all warnings", func() {
   263  						Expect(executeErr).ToNot(HaveOccurred())
   264  
   265  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   266  						appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   267  						Expect(appName).To(Equal("some-app-name"))
   268  						Expect(spaceGUID).To(Equal("some-space-guid"))
   269  
   270  						Expect(fakeActor.RunTaskCallCount()).To(Equal(1))
   271  						appGUID, task := fakeActor.RunTaskArgsForCall(0)
   272  						Expect(appGUID).To(Equal("some-app-guid"))
   273  						Expect(task).To(Equal(v3action.Task{
   274  							Command:    "some command",
   275  							Name:       "some-task-name",
   276  							MemoryInMB: 123,
   277  						}))
   278  
   279  						Expect(testUI.Out).To(Say(`Creating task for app some-app-name in org some-org / space some-space as some-user...
   280  OK
   281  
   282  Task has been submitted successfully for execution.
   283  task name:   some-task-name
   284  task id:     3`,
   285  						))
   286  						Expect(testUI.Err).To(Say(`get-application-warning-1
   287  get-application-warning-2
   288  get-application-warning-3`))
   289  					})
   290  				})
   291  			})
   292  
   293  			Context("when there are errors", func() {
   294  				Context("when the error is translatable", func() {
   295  					Context("when getting the app returns the error", func() {
   296  						var (
   297  							returnedErr error
   298  							expectedErr error
   299  						)
   300  
   301  						BeforeEach(func() {
   302  							expectedErr = errors.New("request-error")
   303  							returnedErr = ccerror.RequestError{Err: expectedErr}
   304  							fakeActor.GetApplicationByNameAndSpaceReturns(
   305  								v3action.Application{GUID: "some-app-guid"},
   306  								nil,
   307  								returnedErr)
   308  						})
   309  
   310  						It("returns a translatable error", func() {
   311  							Expect(executeErr).To(MatchError(translatableerror.APIRequestError{Err: expectedErr}))
   312  						})
   313  					})
   314  
   315  					Context("when running the task returns the error", func() {
   316  						var returnedErr error
   317  
   318  						BeforeEach(func() {
   319  							returnedErr = ccerror.UnverifiedServerError{URL: "some-url"}
   320  							fakeActor.GetApplicationByNameAndSpaceReturns(
   321  								v3action.Application{GUID: "some-app-guid"},
   322  								nil,
   323  								nil)
   324  							fakeActor.RunTaskReturns(
   325  								v3action.Task{},
   326  								nil,
   327  								returnedErr)
   328  						})
   329  
   330  						It("returns a translatable error", func() {
   331  							Expect(executeErr).To(MatchError(translatableerror.InvalidSSLCertError{API: "some-url"}))
   332  						})
   333  					})
   334  				})
   335  
   336  				Context("when the error is not translatable", func() {
   337  					Context("when getting the app returns the error", func() {
   338  						var expectedErr error
   339  
   340  						BeforeEach(func() {
   341  							expectedErr = errors.New("got bananapants??")
   342  							fakeActor.GetApplicationByNameAndSpaceReturns(
   343  								v3action.Application{GUID: "some-app-guid"},
   344  								v3action.Warnings{"get-application-warning-1", "get-application-warning-2"},
   345  								expectedErr)
   346  						})
   347  
   348  						It("return the error and all warnings", func() {
   349  							Expect(executeErr).To(MatchError(expectedErr))
   350  
   351  							Expect(testUI.Err).To(Say("get-application-warning-1"))
   352  							Expect(testUI.Err).To(Say("get-application-warning-2"))
   353  						})
   354  					})
   355  
   356  					Context("when running the task returns an error", func() {
   357  						var expectedErr error
   358  
   359  						BeforeEach(func() {
   360  							expectedErr = errors.New("got bananapants??")
   361  							fakeActor.GetApplicationByNameAndSpaceReturns(
   362  								v3action.Application{GUID: "some-app-guid"},
   363  								v3action.Warnings{"get-application-warning-1", "get-application-warning-2"},
   364  								nil)
   365  							fakeActor.RunTaskReturns(
   366  								v3action.Task{},
   367  								v3action.Warnings{"run-task-warning-1", "run-task-warning-2"},
   368  								expectedErr)
   369  						})
   370  
   371  						It("returns the error and all warnings", func() {
   372  							Expect(executeErr).To(MatchError(expectedErr))
   373  
   374  							Expect(testUI.Err).To(Say("get-application-warning-1"))
   375  							Expect(testUI.Err).To(Say("get-application-warning-2"))
   376  							Expect(testUI.Err).To(Say("run-task-warning-1"))
   377  							Expect(testUI.Err).To(Say("run-task-warning-2"))
   378  						})
   379  					})
   380  				})
   381  			})
   382  		})
   383  	})
   384  })