github.com/jghiloni/cli@v6.28.1-0.20170628223758-0ce05fe032a2+incompatible/actor/v3action/application_summary_test.go (about)

     1  package v3action_test
     2  
     3  import (
     4  	"errors"
     5  	"net/url"
     6  
     7  	. "code.cloudfoundry.org/cli/actor/v3action"
     8  	"code.cloudfoundry.org/cli/actor/v3action/v3actionfakes"
     9  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
    10  
    11  	. "github.com/onsi/ginkgo"
    12  	. "github.com/onsi/gomega"
    13  )
    14  
    15  var _ = Describe("Application Summary Actions", func() {
    16  	var (
    17  		actor                     *Actor
    18  		fakeCloudControllerClient *v3actionfakes.FakeCloudControllerClient
    19  	)
    20  
    21  	BeforeEach(func() {
    22  		fakeCloudControllerClient = new(v3actionfakes.FakeCloudControllerClient)
    23  		actor = NewActor(fakeCloudControllerClient, nil)
    24  	})
    25  
    26  	Describe("GetApplicationSummaryByNameAndSpace", func() {
    27  		Context("when the app exists", func() {
    28  			BeforeEach(func() {
    29  				fakeCloudControllerClient.GetApplicationsReturns(
    30  					[]ccv3.Application{
    31  						{
    32  							Name:  "some-app-name",
    33  							GUID:  "some-app-guid",
    34  							State: "RUNNING",
    35  						},
    36  					},
    37  					ccv3.Warnings{"some-warning"},
    38  					nil,
    39  				)
    40  
    41  				fakeCloudControllerClient.GetApplicationCurrentDropletReturns(
    42  					ccv3.Droplet{
    43  						Stack: "some-stack",
    44  						Buildpacks: []ccv3.Buildpack{
    45  							{
    46  								Name: "some-buildpack",
    47  							},
    48  						},
    49  					},
    50  					ccv3.Warnings{"some-droplet-warning"},
    51  					nil,
    52  				)
    53  
    54  				fakeCloudControllerClient.GetApplicationProcessesReturns(
    55  					[]ccv3.Process{
    56  						{
    57  							GUID:       "some-process-guid",
    58  							Type:       "some-type",
    59  							MemoryInMB: 32,
    60  						},
    61  					},
    62  					ccv3.Warnings{"some-process-warning"},
    63  					nil,
    64  				)
    65  
    66  				fakeCloudControllerClient.GetProcessInstancesReturns(
    67  					[]ccv3.Instance{
    68  						{
    69  							State:       "RUNNING",
    70  							CPU:         0.01,
    71  							MemoryUsage: 1000000,
    72  							DiskUsage:   2000000,
    73  							MemoryQuota: 3000000,
    74  							DiskQuota:   4000000,
    75  							Index:       0,
    76  						},
    77  					},
    78  					ccv3.Warnings{"some-process-stats-warning"},
    79  					nil,
    80  				)
    81  			})
    82  
    83  			It("returns the summary and warnings", func() {
    84  				summary, warnings, err := actor.GetApplicationSummaryByNameAndSpace("some-app-name", "some-space-guid")
    85  				Expect(err).ToNot(HaveOccurred())
    86  				Expect(summary).To(Equal(ApplicationSummary{
    87  					Application: Application{
    88  						Name:  "some-app-name",
    89  						GUID:  "some-app-guid",
    90  						State: "RUNNING",
    91  					},
    92  					CurrentDroplet: Droplet{
    93  						Stack: "some-stack",
    94  						Buildpacks: []Buildpack{
    95  							{
    96  								Name: "some-buildpack",
    97  							},
    98  						},
    99  					},
   100  					Processes: []Process{
   101  						Process{
   102  							MemoryInMB: 32,
   103  							Type:       "some-type",
   104  							Instances: []Instance{
   105  								{
   106  									State:       "RUNNING",
   107  									CPU:         0.01,
   108  									MemoryUsage: 1000000,
   109  									DiskUsage:   2000000,
   110  									MemoryQuota: 3000000,
   111  									DiskQuota:   4000000,
   112  									Index:       0,
   113  								},
   114  							},
   115  						},
   116  					},
   117  				}))
   118  				Expect(warnings).To(Equal(Warnings{"some-warning", "some-droplet-warning", "some-process-warning", "some-process-stats-warning"}))
   119  
   120  				Expect(fakeCloudControllerClient.GetApplicationsCallCount()).To(Equal(1))
   121  				expectedQuery := url.Values{
   122  					"names":       []string{"some-app-name"},
   123  					"space_guids": []string{"some-space-guid"},
   124  				}
   125  				query := fakeCloudControllerClient.GetApplicationsArgsForCall(0)
   126  				Expect(query).To(Equal(expectedQuery))
   127  
   128  				Expect(fakeCloudControllerClient.GetApplicationProcessesCallCount()).To(Equal(1))
   129  				appGUID := fakeCloudControllerClient.GetApplicationProcessesArgsForCall(0)
   130  				Expect(appGUID).To(Equal("some-app-guid"))
   131  
   132  				Expect(fakeCloudControllerClient.GetProcessInstancesCallCount()).To(Equal(1))
   133  				processGUID := fakeCloudControllerClient.GetProcessInstancesArgsForCall(0)
   134  				Expect(processGUID).To(Equal("some-process-guid"))
   135  			})
   136  		})
   137  
   138  		Context("when the app is not found", func() {
   139  			BeforeEach(func() {
   140  				fakeCloudControllerClient.GetApplicationsReturns(
   141  					[]ccv3.Application{},
   142  					ccv3.Warnings{"some-warning"},
   143  					nil,
   144  				)
   145  			})
   146  
   147  			It("returns the error and warnings", func() {
   148  				_, warnings, err := actor.GetApplicationSummaryByNameAndSpace("some-app-name", "some-space-guid")
   149  				Expect(err).To(Equal(ApplicationNotFoundError{Name: "some-app-name"}))
   150  				Expect(warnings).To(Equal(Warnings{"some-warning"}))
   151  			})
   152  		})
   153  
   154  		Context("when getting the current droplet returns an error", func() {
   155  			var expectedErr error
   156  
   157  			BeforeEach(func() {
   158  				fakeCloudControllerClient.GetApplicationsReturns(
   159  					[]ccv3.Application{
   160  						{
   161  							Name:  "some-app-name",
   162  							GUID:  "some-app-guid",
   163  							State: "RUNNING",
   164  						},
   165  					},
   166  					ccv3.Warnings{"some-warning"},
   167  					nil,
   168  				)
   169  
   170  				expectedErr = errors.New("some error")
   171  				fakeCloudControllerClient.GetApplicationCurrentDropletReturns(
   172  					ccv3.Droplet{},
   173  					ccv3.Warnings{"some-droplet-warning"},
   174  					expectedErr,
   175  				)
   176  			})
   177  
   178  			It("returns the error", func() {
   179  				_, warnings, err := actor.GetApplicationSummaryByNameAndSpace("some-app-name", "some-space-guid")
   180  				Expect(err).To(Equal(expectedErr))
   181  				Expect(warnings).To(Equal(Warnings{"some-warning", "some-droplet-warning"}))
   182  			})
   183  		})
   184  
   185  		Context("when getting the app processes returns an error", func() {
   186  			var expectedErr error
   187  
   188  			BeforeEach(func() {
   189  				fakeCloudControllerClient.GetApplicationsReturns(
   190  					[]ccv3.Application{
   191  						{
   192  							Name:  "some-app-name",
   193  							GUID:  "some-app-guid",
   194  							State: "RUNNING",
   195  						},
   196  					},
   197  					ccv3.Warnings{"some-warning"},
   198  					nil,
   199  				)
   200  
   201  				fakeCloudControllerClient.GetApplicationCurrentDropletReturns(
   202  					ccv3.Droplet{
   203  						Stack: "some-stack",
   204  						Buildpacks: []ccv3.Buildpack{
   205  							{
   206  								Name: "some-buildpack",
   207  							},
   208  						},
   209  					},
   210  					ccv3.Warnings{"some-droplet-warning"},
   211  					nil,
   212  				)
   213  
   214  				expectedErr = errors.New("some error")
   215  				fakeCloudControllerClient.GetApplicationProcessesReturns(
   216  					[]ccv3.Process{},
   217  					ccv3.Warnings{"some-process-warning"},
   218  					expectedErr,
   219  				)
   220  			})
   221  
   222  			It("returns the error", func() {
   223  				_, warnings, err := actor.GetApplicationSummaryByNameAndSpace("some-app-name", "some-space-guid")
   224  				Expect(err).To(Equal(expectedErr))
   225  				Expect(warnings).To(Equal(Warnings{"some-warning", "some-droplet-warning", "some-process-warning"}))
   226  			})
   227  		})
   228  
   229  		Context("when getting the app process instances returns an error", func() {
   230  			var expectedErr error
   231  
   232  			BeforeEach(func() {
   233  				fakeCloudControllerClient.GetApplicationsReturns(
   234  					[]ccv3.Application{
   235  						{
   236  							Name:  "some-app-name",
   237  							GUID:  "some-app-guid",
   238  							State: "RUNNING",
   239  						},
   240  					},
   241  					ccv3.Warnings{"some-warning"},
   242  					nil,
   243  				)
   244  
   245  				fakeCloudControllerClient.GetApplicationCurrentDropletReturns(
   246  					ccv3.Droplet{
   247  						Stack: "some-stack",
   248  						Buildpacks: []ccv3.Buildpack{
   249  							{
   250  								Name: "some-buildpack",
   251  							},
   252  						},
   253  					},
   254  					ccv3.Warnings{"some-droplet-warning"},
   255  					nil,
   256  				)
   257  
   258  				fakeCloudControllerClient.GetApplicationProcessesReturns(
   259  					[]ccv3.Process{
   260  						{
   261  							GUID: "some-process-guid",
   262  							Type: "some-type",
   263  						},
   264  					},
   265  					ccv3.Warnings{"some-process-warning"},
   266  					nil,
   267  				)
   268  
   269  				expectedErr = errors.New("some error")
   270  				fakeCloudControllerClient.GetProcessInstancesReturns(
   271  					[]ccv3.Instance{},
   272  					ccv3.Warnings{"some-process-stats-warning"},
   273  					expectedErr,
   274  				)
   275  			})
   276  
   277  			It("returns the error", func() {
   278  				_, warnings, err := actor.GetApplicationSummaryByNameAndSpace("some-app-name", "some-space-guid")
   279  				Expect(err).To(Equal(expectedErr))
   280  				Expect(warnings).To(Equal(Warnings{"some-warning", "some-droplet-warning", "some-process-warning", "some-process-stats-warning"}))
   281  			})
   282  		})
   283  	})
   284  })