github.com/LukasHeimann/cloudfoundrycli/v8@v8.4.4/command/v7/map_route_command_test.go (about)

     1  package v7_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	"github.com/LukasHeimann/cloudfoundrycli/v8/actor/actionerror"
     7  	"github.com/LukasHeimann/cloudfoundrycli/v8/actor/v7action"
     8  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/commandfakes"
     9  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/flag"
    10  	. "github.com/LukasHeimann/cloudfoundrycli/v8/command/v7"
    11  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/v7/v7fakes"
    12  	"github.com/LukasHeimann/cloudfoundrycli/v8/resources"
    13  	"github.com/LukasHeimann/cloudfoundrycli/v8/util/configv3"
    14  	"github.com/LukasHeimann/cloudfoundrycli/v8/util/ui"
    15  
    16  	. "github.com/onsi/ginkgo"
    17  	. "github.com/onsi/gomega"
    18  	. "github.com/onsi/gomega/gbytes"
    19  )
    20  
    21  var _ = Describe("map-route Command", func() {
    22  	var (
    23  		cmd             MapRouteCommand
    24  		testUI          *ui.UI
    25  		fakeConfig      *commandfakes.FakeConfig
    26  		fakeSharedActor *commandfakes.FakeSharedActor
    27  		fakeActor       *v7fakes.FakeActor
    28  		input           *Buffer
    29  		binaryName      string
    30  		executeErr      error
    31  		domain          string
    32  		appName         string
    33  		hostname        string
    34  		path            string
    35  		orgGUID         string
    36  		spaceGUID       string
    37  	)
    38  
    39  	BeforeEach(func() {
    40  		input = NewBuffer()
    41  		testUI = ui.NewTestUI(input, NewBuffer(), NewBuffer())
    42  		fakeConfig = new(commandfakes.FakeConfig)
    43  		fakeSharedActor = new(commandfakes.FakeSharedActor)
    44  		fakeActor = new(v7fakes.FakeActor)
    45  
    46  		binaryName = "faceman"
    47  		fakeConfig.BinaryNameReturns(binaryName)
    48  		appName = "my-app"
    49  		domain = "some-domain.com"
    50  		hostname = "host"
    51  		path = `path`
    52  		orgGUID = "some-org-guid"
    53  		spaceGUID = "some-space-guid"
    54  
    55  		cmd = MapRouteCommand{
    56  			RequiredArgs: flag.AppDomain{App: appName, Domain: domain},
    57  			Hostname:     hostname,
    58  			Path:         flag.V7RoutePath{Path: path},
    59  			AppProtocol:  "http2",
    60  			BaseCommand: BaseCommand{
    61  				UI:          testUI,
    62  				Config:      fakeConfig,
    63  				SharedActor: fakeSharedActor,
    64  				Actor:       fakeActor,
    65  			},
    66  		}
    67  
    68  		fakeConfig.TargetedOrganizationReturns(configv3.Organization{
    69  			Name: "some-org",
    70  			GUID: orgGUID,
    71  		})
    72  
    73  		fakeConfig.TargetedSpaceReturns(configv3.Space{
    74  			Name: "some-space",
    75  			GUID: spaceGUID,
    76  		})
    77  
    78  		fakeActor.GetCurrentUserReturns(configv3.User{Name: "steve"}, nil)
    79  	})
    80  
    81  	JustBeforeEach(func() {
    82  		executeErr = cmd.Execute(nil)
    83  	})
    84  
    85  	When("checking target fails", func() {
    86  		BeforeEach(func() {
    87  			fakeSharedActor.CheckTargetReturns(actionerror.NoOrganizationTargetedError{BinaryName: binaryName})
    88  		})
    89  
    90  		It("returns an error", func() {
    91  			Expect(executeErr).To(MatchError(actionerror.NoOrganizationTargetedError{BinaryName: binaryName}))
    92  
    93  			Expect(fakeSharedActor.CheckTargetCallCount()).To(Equal(1))
    94  			checkTargetedOrg, checkTargetedSpace := fakeSharedActor.CheckTargetArgsForCall(0)
    95  			Expect(checkTargetedOrg).To(BeTrue())
    96  			Expect(checkTargetedSpace).To(BeTrue())
    97  		})
    98  	})
    99  
   100  	When("the user is not logged in", func() {
   101  		var expectedErr error
   102  
   103  		BeforeEach(func() {
   104  			expectedErr = errors.New("some current user error")
   105  			fakeActor.GetCurrentUserReturns(configv3.User{}, expectedErr)
   106  		})
   107  
   108  		It("return an error", func() {
   109  			Expect(executeErr).To(Equal(expectedErr))
   110  		})
   111  	})
   112  
   113  	When("the user is logged in and targeted", func() {
   114  		When("getting the domain errors", func() {
   115  			BeforeEach(func() {
   116  				fakeActor.GetDomainByNameReturns(resources.Domain{}, v7action.Warnings{"get-domain-warnings"}, errors.New("get-domain-error"))
   117  			})
   118  
   119  			It("returns the error and displays warnings", func() {
   120  				Expect(testUI.Err).To(Say("get-domain-warnings"))
   121  				Expect(executeErr).To(MatchError(errors.New("get-domain-error")))
   122  
   123  				Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   124  				Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   125  
   126  				Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(0))
   127  
   128  				Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(0))
   129  
   130  				Expect(fakeActor.CreateRouteCallCount()).To(Equal(0))
   131  
   132  				Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   133  			})
   134  		})
   135  
   136  		When("getting the domain succeeds", func() {
   137  			BeforeEach(func() {
   138  				fakeActor.GetDomainByNameReturns(
   139  					resources.Domain{Name: "some-domain.com", GUID: "domain-guid"},
   140  					v7action.Warnings{"get-domain-warnings"},
   141  					nil,
   142  				)
   143  			})
   144  
   145  			When("getting the app errors", func() {
   146  				BeforeEach(func() {
   147  					fakeActor.GetApplicationByNameAndSpaceReturns(
   148  						resources.Application{},
   149  						v7action.Warnings{"get-app-warnings"},
   150  						errors.New("get-app-error"),
   151  					)
   152  				})
   153  
   154  				It("returns the error and displays warnings", func() {
   155  					Expect(testUI.Err).To(Say("get-domain-warnings"))
   156  					Expect(testUI.Err).To(Say("get-app-warnings"))
   157  					Expect(executeErr).To(MatchError(errors.New("get-app-error")))
   158  
   159  					Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   160  					Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   161  
   162  					Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   163  					actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   164  					Expect(actualAppName).To(Equal(appName))
   165  					Expect(actualSpaceGUID).To(Equal(spaceGUID))
   166  
   167  					Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(0))
   168  
   169  					Expect(fakeActor.CreateRouteCallCount()).To(Equal(0))
   170  
   171  					Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   172  				})
   173  			})
   174  
   175  			When("getting the app succeeds", func() {
   176  				BeforeEach(func() {
   177  					fakeActor.GetApplicationByNameAndSpaceReturns(
   178  						resources.Application{Name: "app", GUID: "app-guid"},
   179  						v7action.Warnings{"get-app-warnings"},
   180  						nil,
   181  					)
   182  				})
   183  
   184  				When("getting the route errors", func() {
   185  					BeforeEach(func() {
   186  						fakeActor.GetRouteByAttributesReturns(
   187  							resources.Route{},
   188  							v7action.Warnings{"get-route-warnings"},
   189  							errors.New("get-route-error"),
   190  						)
   191  					})
   192  
   193  					It("returns the error and displays warnings", func() {
   194  						Expect(testUI.Err).To(Say("get-domain-warnings"))
   195  						Expect(testUI.Err).To(Say("get-app-warnings"))
   196  						Expect(testUI.Err).To(Say("get-route-warnings"))
   197  						Expect(executeErr).To(MatchError(errors.New("get-route-error")))
   198  
   199  						Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   200  						Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   201  
   202  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   203  						actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   204  						Expect(actualAppName).To(Equal(appName))
   205  						Expect(actualSpaceGUID).To(Equal(spaceGUID))
   206  
   207  						Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   208  						actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   209  						Expect(actualDomain.Name).To(Equal("some-domain.com"))
   210  						Expect(actualDomain.GUID).To(Equal("domain-guid"))
   211  						Expect(actualHostname).To(Equal(hostname))
   212  						Expect(actualPath).To(Equal(path))
   213  						Expect(actualPort).To(Equal(cmd.Port))
   214  
   215  						Expect(fakeActor.CreateRouteCallCount()).To(Equal(0))
   216  
   217  						Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   218  					})
   219  				})
   220  
   221  				When("the requested route does not exist", func() {
   222  					BeforeEach(func() {
   223  						fakeActor.GetRouteByAttributesReturns(
   224  							resources.Route{},
   225  							v7action.Warnings{"get-route-warnings"},
   226  							actionerror.RouteNotFoundError{},
   227  						)
   228  					})
   229  
   230  					It("creates the route", func() {
   231  						Expect(testUI.Err).To(Say("get-domain-warnings"))
   232  						Expect(testUI.Err).To(Say("get-app-warnings"))
   233  						Expect(testUI.Err).To(Say("get-route-warnings"))
   234  						Expect(executeErr).ToNot(HaveOccurred())
   235  
   236  						Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   237  						Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   238  
   239  						Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   240  						actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   241  						Expect(actualAppName).To(Equal(appName))
   242  						Expect(actualSpaceGUID).To(Equal(spaceGUID))
   243  
   244  						Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   245  						actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   246  						Expect(actualDomain.Name).To(Equal("some-domain.com"))
   247  						Expect(actualDomain.GUID).To(Equal("domain-guid"))
   248  						Expect(actualHostname).To(Equal(hostname))
   249  						Expect(actualPath).To(Equal(path))
   250  						Expect(actualPort).To(Equal(cmd.Port))
   251  
   252  						Expect(fakeActor.CreateRouteCallCount()).To(Equal(1))
   253  						actualSpaceGUID, actualDomainName, actualHostname, actualPath, actualPort := fakeActor.CreateRouteArgsForCall(0)
   254  						Expect(actualSpaceGUID).To(Equal(spaceGUID))
   255  						Expect(actualDomainName).To(Equal("some-domain.com"))
   256  						Expect(actualHostname).To(Equal(hostname))
   257  						Expect(actualPath).To(Equal(path))
   258  						Expect(actualPort).To(Equal(cmd.Port))
   259  					})
   260  				})
   261  
   262  				When("the requested route exists", func() {
   263  					BeforeEach(func() {
   264  						fakeActor.GetRouteByAttributesReturns(
   265  							resources.Route{GUID: "route-guid"},
   266  							v7action.Warnings{"get-route-warnings"},
   267  							nil,
   268  						)
   269  					})
   270  
   271  					When("getting the destination errors", func() {
   272  						BeforeEach(func() {
   273  							fakeActor.GetRouteDestinationByAppGUIDReturns(
   274  								resources.RouteDestination{},
   275  								errors.New("get-destination-error"),
   276  							)
   277  						})
   278  						It("returns the error and warnings", func() {
   279  							Expect(executeErr).To(MatchError(errors.New("get-destination-error")))
   280  
   281  							Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   282  							Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   283  
   284  							Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   285  							actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   286  							Expect(actualAppName).To(Equal(appName))
   287  							Expect(actualSpaceGUID).To(Equal(spaceGUID))
   288  
   289  							Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   290  							actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   291  							Expect(actualDomain.Name).To(Equal("some-domain.com"))
   292  							Expect(actualDomain.GUID).To(Equal("domain-guid"))
   293  							Expect(actualHostname).To(Equal(hostname))
   294  							Expect(actualPath).To(Equal(path))
   295  							Expect(actualPort).To(Equal(cmd.Port))
   296  
   297  							Expect(fakeActor.GetRouteDestinationByAppGUIDCallCount()).To(Equal(1))
   298  							actualRoute, actualAppGUID := fakeActor.GetRouteDestinationByAppGUIDArgsForCall(0)
   299  							Expect(actualRoute.GUID).To(Equal("route-guid"))
   300  							Expect(actualAppGUID).To(Equal("app-guid"))
   301  
   302  							Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   303  						})
   304  					})
   305  
   306  					When("the destination already exists", func() {
   307  						BeforeEach(func() {
   308  							fakeActor.GetRouteDestinationByAppGUIDReturns(
   309  								resources.RouteDestination{
   310  									GUID: "route-dst-guid",
   311  									App: resources.RouteDestinationApp{
   312  										GUID: "existing-app-guid",
   313  									},
   314  								},
   315  								nil,
   316  							)
   317  						})
   318  						It("exits 0 with a helpful message that the route is already mapped to the app", func() {
   319  							Expect(executeErr).ShouldNot(HaveOccurred())
   320  
   321  							Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   322  							Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   323  
   324  							Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   325  							actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   326  							Expect(actualAppName).To(Equal(appName))
   327  							Expect(actualSpaceGUID).To(Equal(spaceGUID))
   328  
   329  							Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   330  							actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   331  							Expect(actualDomain.Name).To(Equal("some-domain.com"))
   332  							Expect(actualDomain.GUID).To(Equal("domain-guid"))
   333  							Expect(actualHostname).To(Equal(hostname))
   334  							Expect(actualPath).To(Equal(path))
   335  							Expect(actualPort).To(Equal(cmd.Port))
   336  
   337  							Expect(fakeActor.GetRouteDestinationByAppGUIDCallCount()).To(Equal(1))
   338  							actualRoute, actualAppGUID := fakeActor.GetRouteDestinationByAppGUIDArgsForCall(0)
   339  							Expect(actualRoute.GUID).To(Equal("route-guid"))
   340  							Expect(actualAppGUID).To(Equal("app-guid"))
   341  							Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   342  						})
   343  
   344  					})
   345  					When("the destination is not found", func() {
   346  						When("mapping the route errors", func() {
   347  							BeforeEach(func() {
   348  								fakeActor.MapRouteReturns(v7action.Warnings{"map-route-warnings"}, errors.New("map-route-error"))
   349  							})
   350  
   351  							It("returns the error and displays warnings", func() {
   352  								Expect(testUI.Err).To(Say("get-domain-warnings"))
   353  								Expect(testUI.Err).To(Say("get-app-warnings"))
   354  								Expect(testUI.Err).To(Say("get-route-warnings"))
   355  								Expect(testUI.Err).To(Say("map-route-warnings"))
   356  								Expect(executeErr).To(MatchError(errors.New("map-route-error")))
   357  
   358  								Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   359  								Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   360  
   361  								Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   362  								actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   363  								Expect(actualAppName).To(Equal(appName))
   364  								Expect(actualSpaceGUID).To(Equal(spaceGUID))
   365  
   366  								Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   367  								actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   368  								Expect(actualDomain.Name).To(Equal("some-domain.com"))
   369  								Expect(actualDomain.GUID).To(Equal("domain-guid"))
   370  								Expect(actualHostname).To(Equal(hostname))
   371  								Expect(actualPath).To(Equal(path))
   372  								Expect(actualPort).To(Equal(cmd.Port))
   373  
   374  								Expect(fakeActor.MapRouteCallCount()).To(Equal(1))
   375  								actualRouteGUID, actualAppGUID, actualAppProtocol := fakeActor.MapRouteArgsForCall(0)
   376  								Expect(actualRouteGUID).To(Equal("route-guid"))
   377  								Expect(actualAppGUID).To(Equal("app-guid"))
   378  								Expect(actualAppProtocol).To(Equal("http2"))
   379  							})
   380  						})
   381  
   382  						When("mapping the route succeeds", func() {
   383  							BeforeEach(func() {
   384  								fakeActor.MapRouteReturns(v7action.Warnings{"map-route-warnings"}, nil)
   385  							})
   386  
   387  							It("returns the proper information and passing the proper arguments", func() {
   388  								By("displaying warnings", func() {
   389  									Expect(testUI.Err).To(Say("get-domain-warnings"))
   390  									Expect(testUI.Err).To(Say("get-app-warnings"))
   391  									Expect(testUI.Err).To(Say("get-route-warnings"))
   392  									Expect(testUI.Err).To(Say("map-route-warnings"))
   393  									Expect(executeErr).ToNot(HaveOccurred())
   394  								})
   395  
   396  								By("passing the expected arguments to the actor", func() {
   397  									Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   398  									Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   399  
   400  									Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   401  									actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   402  									Expect(actualAppName).To(Equal(appName))
   403  									Expect(actualSpaceGUID).To(Equal(spaceGUID))
   404  
   405  									Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   406  									actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   407  									Expect(actualDomain.Name).To(Equal("some-domain.com"))
   408  									Expect(actualDomain.GUID).To(Equal("domain-guid"))
   409  									Expect(actualHostname).To(Equal("host"))
   410  									Expect(actualPath).To(Equal(path))
   411  									Expect(actualPort).To(Equal(cmd.Port))
   412  
   413  									Expect(fakeActor.MapRouteCallCount()).To(Equal(1))
   414  									actualRouteGUID, actualAppGUID, actualAppProtocol := fakeActor.MapRouteArgsForCall(0)
   415  									Expect(actualRouteGUID).To(Equal("route-guid"))
   416  									Expect(actualAppGUID).To(Equal("app-guid"))
   417  									Expect(actualAppProtocol).To(Equal("http2"))
   418  								})
   419  							})
   420  						})
   421  					})
   422  				})
   423  
   424  				When("a tcp route is requested without a port", func() {
   425  					BeforeEach(func() {
   426  						fakeActor.GetRouteByAttributesReturns(
   427  							resources.Route{GUID: "route-guid"},
   428  							v7action.Warnings{"get-route-warnings"},
   429  							nil,
   430  						)
   431  					})
   432  
   433  					When("getting the destination errors", func() {
   434  						BeforeEach(func() {
   435  							fakeActor.GetRouteDestinationByAppGUIDReturns(
   436  								resources.RouteDestination{},
   437  								errors.New("get-destination-error"),
   438  							)
   439  						})
   440  						It("returns the error and warnings", func() {
   441  							Expect(executeErr).To(MatchError(errors.New("get-destination-error")))
   442  
   443  							Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   444  							Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   445  
   446  							Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   447  							actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   448  							Expect(actualAppName).To(Equal(appName))
   449  							Expect(actualSpaceGUID).To(Equal(spaceGUID))
   450  
   451  							Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   452  							actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   453  							Expect(actualDomain.Name).To(Equal("some-domain.com"))
   454  							Expect(actualDomain.GUID).To(Equal("domain-guid"))
   455  							Expect(actualHostname).To(Equal(hostname))
   456  							Expect(actualPath).To(Equal(path))
   457  							Expect(actualPort).To(Equal(cmd.Port))
   458  
   459  							Expect(fakeActor.GetRouteDestinationByAppGUIDCallCount()).To(Equal(1))
   460  							actualRoute, actualAppGUID := fakeActor.GetRouteDestinationByAppGUIDArgsForCall(0)
   461  							Expect(actualRoute.GUID).To(Equal("route-guid"))
   462  							Expect(actualAppGUID).To(Equal("app-guid"))
   463  
   464  							Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   465  						})
   466  					})
   467  
   468  					When("the destination already exists", func() {
   469  						BeforeEach(func() {
   470  							fakeActor.GetRouteDestinationByAppGUIDReturns(
   471  								resources.RouteDestination{
   472  									GUID: "route-dst-guid",
   473  									App: resources.RouteDestinationApp{
   474  										GUID: "existing-app-guid",
   475  									},
   476  								},
   477  								nil,
   478  							)
   479  						})
   480  						It("exits 0 with a helpful message that the route is already mapped to the app", func() {
   481  							Expect(executeErr).ShouldNot(HaveOccurred())
   482  
   483  							Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   484  							Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   485  
   486  							Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   487  							actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   488  							Expect(actualAppName).To(Equal(appName))
   489  							Expect(actualSpaceGUID).To(Equal(spaceGUID))
   490  
   491  							Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   492  							actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   493  							Expect(actualDomain.Name).To(Equal("some-domain.com"))
   494  							Expect(actualDomain.GUID).To(Equal("domain-guid"))
   495  							Expect(actualHostname).To(Equal(hostname))
   496  							Expect(actualPath).To(Equal(path))
   497  							Expect(actualPort).To(Equal(cmd.Port))
   498  
   499  							Expect(fakeActor.GetRouteDestinationByAppGUIDCallCount()).To(Equal(1))
   500  							actualRoute, actualAppGUID := fakeActor.GetRouteDestinationByAppGUIDArgsForCall(0)
   501  							Expect(actualRoute.GUID).To(Equal("route-guid"))
   502  							Expect(actualAppGUID).To(Equal("app-guid"))
   503  							Expect(fakeActor.MapRouteCallCount()).To(Equal(0))
   504  						})
   505  
   506  					})
   507  					When("the destination is not found", func() {
   508  						When("mapping the route errors", func() {
   509  							BeforeEach(func() {
   510  								fakeActor.MapRouteReturns(v7action.Warnings{"map-route-warnings"}, errors.New("map-route-error"))
   511  							})
   512  
   513  							It("returns the error and displays warnings", func() {
   514  								Expect(testUI.Err).To(Say("get-domain-warnings"))
   515  								Expect(testUI.Err).To(Say("get-app-warnings"))
   516  								Expect(testUI.Err).To(Say("get-route-warnings"))
   517  								Expect(testUI.Err).To(Say("map-route-warnings"))
   518  								Expect(executeErr).To(MatchError(errors.New("map-route-error")))
   519  
   520  								Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   521  								Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   522  
   523  								Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   524  								actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   525  								Expect(actualAppName).To(Equal(appName))
   526  								Expect(actualSpaceGUID).To(Equal(spaceGUID))
   527  
   528  								Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   529  								actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   530  								Expect(actualDomain.Name).To(Equal("some-domain.com"))
   531  								Expect(actualDomain.GUID).To(Equal("domain-guid"))
   532  								Expect(actualHostname).To(Equal(hostname))
   533  								Expect(actualPath).To(Equal(path))
   534  								Expect(actualPort).To(Equal(cmd.Port))
   535  
   536  								Expect(fakeActor.MapRouteCallCount()).To(Equal(1))
   537  								actualRouteGUID, actualAppGUID, actualAppProtocol := fakeActor.MapRouteArgsForCall(0)
   538  								Expect(actualRouteGUID).To(Equal("route-guid"))
   539  								Expect(actualAppGUID).To(Equal("app-guid"))
   540  								Expect(actualAppProtocol).To(Equal("http2"))
   541  							})
   542  						})
   543  
   544  						When("mapping the route succeeds", func() {
   545  							BeforeEach(func() {
   546  								fakeActor.MapRouteReturns(v7action.Warnings{"map-route-warnings"}, nil)
   547  							})
   548  
   549  							It("returns the proper information and passing the proper arguments", func() {
   550  								By("displaying warnings", func() {
   551  									Expect(testUI.Err).To(Say("get-domain-warnings"))
   552  									Expect(testUI.Err).To(Say("get-app-warnings"))
   553  									Expect(testUI.Err).To(Say("get-route-warnings"))
   554  									Expect(testUI.Err).To(Say("map-route-warnings"))
   555  									Expect(executeErr).ToNot(HaveOccurred())
   556  								})
   557  
   558  								By("passing the expected arguments to the actor ", func() {
   559  									Expect(fakeActor.GetDomainByNameCallCount()).To(Equal(1))
   560  									Expect(fakeActor.GetDomainByNameArgsForCall(0)).To(Equal(domain))
   561  
   562  									Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1))
   563  									actualAppName, actualSpaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
   564  									Expect(actualAppName).To(Equal(appName))
   565  									Expect(actualSpaceGUID).To(Equal(spaceGUID))
   566  
   567  									Expect(fakeActor.GetRouteByAttributesCallCount()).To(Equal(1))
   568  									actualDomain, actualHostname, actualPath, actualPort := fakeActor.GetRouteByAttributesArgsForCall(0)
   569  									Expect(actualDomain.Name).To(Equal("some-domain.com"))
   570  									Expect(actualDomain.GUID).To(Equal("domain-guid"))
   571  									Expect(actualHostname).To(Equal("host"))
   572  									Expect(actualPath).To(Equal(path))
   573  									Expect(actualPort).To(Equal(cmd.Port))
   574  
   575  									Expect(fakeActor.MapRouteCallCount()).To(Equal(1))
   576  									actualRouteGUID, actualAppGUID, actualAppProtocol := fakeActor.MapRouteArgsForCall(0)
   577  									Expect(actualRouteGUID).To(Equal("route-guid"))
   578  									Expect(actualAppGUID).To(Equal("app-guid"))
   579  									Expect(actualAppProtocol).To(Equal("http2"))
   580  								})
   581  							})
   582  						})
   583  					})
   584  				})
   585  			})
   586  		})
   587  	})
   588  })