github.com/jenspinney/cli@v6.42.1-0.20190207184520-7450c600020e+incompatible/api/cloudcontroller/ccv3/droplet_test.go (about)

     1  package ccv3_test
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  
     7  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
     8  	. "code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
     9  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
    10  	. "github.com/onsi/ginkgo"
    11  	. "github.com/onsi/gomega"
    12  	. "github.com/onsi/gomega/ghttp"
    13  )
    14  
    15  var _ = Describe("Droplet", func() {
    16  	var client *Client
    17  
    18  	BeforeEach(func() {
    19  		client, _ = NewTestClient()
    20  	})
    21  
    22  	Describe("GetApplicationDropletCurrent", func() {
    23  		var (
    24  			droplet    Droplet
    25  			warnings   Warnings
    26  			executeErr error
    27  		)
    28  
    29  		JustBeforeEach(func() {
    30  			droplet, warnings, executeErr = client.GetApplicationDropletCurrent("some-guid")
    31  		})
    32  
    33  		When("the request succeeds", func() {
    34  			BeforeEach(func() {
    35  				response := `{
    36  					"guid": "some-guid",
    37  					"state": "STAGED",
    38  					"error": null,
    39  					"lifecycle": {
    40  						"type": "buildpack",
    41  						"data": {}
    42  					},
    43  					"buildpacks": [
    44  						{
    45  							"name": "some-buildpack",
    46  							"detect_output": "detected-buildpack"
    47  						}
    48  					],
    49  					"image": "docker/some-image",
    50  					"stack": "some-stack",
    51  					"created_at": "2016-03-28T23:39:34Z",
    52  					"updated_at": "2016-03-28T23:39:47Z"
    53  				}`
    54  				server.AppendHandlers(
    55  					CombineHandlers(
    56  						VerifyRequest(http.MethodGet, "/v3/apps/some-guid/droplets/current"),
    57  						RespondWith(http.StatusOK, response, http.Header{"X-Cf-Warnings": {"warning-1"}}),
    58  					),
    59  				)
    60  			})
    61  
    62  			It("returns the given droplet and all warnings", func() {
    63  				Expect(executeErr).ToNot(HaveOccurred())
    64  
    65  				Expect(droplet).To(Equal(Droplet{
    66  					GUID:  "some-guid",
    67  					Stack: "some-stack",
    68  					State: constant.DropletStaged,
    69  					Buildpacks: []DropletBuildpack{
    70  						{
    71  							Name:         "some-buildpack",
    72  							DetectOutput: "detected-buildpack",
    73  						},
    74  					},
    75  					Image:     "docker/some-image",
    76  					CreatedAt: "2016-03-28T23:39:34Z",
    77  				}))
    78  				Expect(warnings).To(ConsistOf("warning-1"))
    79  			})
    80  		})
    81  
    82  		When("cloud controller returns an error", func() {
    83  			BeforeEach(func() {
    84  				response := `{
    85  					"errors": [
    86  						{
    87  							"code": 10010,
    88  							"detail": "Droplet not found",
    89  							"title": "CF-ResourceNotFound"
    90  						}
    91  					]
    92  				}`
    93  				server.AppendHandlers(
    94  					CombineHandlers(
    95  						VerifyRequest(http.MethodGet, "/v3/apps/some-guid/droplets/current"),
    96  						RespondWith(http.StatusNotFound, response, http.Header{"X-Cf-Warnings": {"warning-1"}}),
    97  					),
    98  				)
    99  			})
   100  
   101  			It("returns the error and all given warnings", func() {
   102  				Expect(executeErr).To(MatchError(ccerror.DropletNotFoundError{}))
   103  				Expect(warnings).To(ConsistOf("warning-1"))
   104  			})
   105  		})
   106  	})
   107  
   108  	Describe("GetDroplet", func() {
   109  		var (
   110  			droplet    Droplet
   111  			warnings   Warnings
   112  			executeErr error
   113  		)
   114  
   115  		JustBeforeEach(func() {
   116  			droplet, warnings, executeErr = client.GetDroplet("some-guid")
   117  		})
   118  
   119  		When("the request succeeds", func() {
   120  			BeforeEach(func() {
   121  				response := `{
   122  					"guid": "some-guid",
   123  					"state": "STAGED",
   124  					"error": null,
   125  					"lifecycle": {
   126  						"type": "buildpack",
   127  						"data": {}
   128  					},
   129  					"buildpacks": [
   130  						{
   131  							"name": "some-buildpack",
   132  							"detect_output": "detected-buildpack"
   133  						}
   134  					],
   135  					"image": "docker/some-image",
   136  					"stack": "some-stack",
   137  					"created_at": "2016-03-28T23:39:34Z",
   138  					"updated_at": "2016-03-28T23:39:47Z"
   139  				}`
   140  				server.AppendHandlers(
   141  					CombineHandlers(
   142  						VerifyRequest(http.MethodGet, "/v3/droplets/some-guid"),
   143  						RespondWith(http.StatusOK, response, http.Header{"X-Cf-Warnings": {"warning-1"}}),
   144  					),
   145  				)
   146  			})
   147  
   148  			It("returns the given droplet and all warnings", func() {
   149  				Expect(executeErr).ToNot(HaveOccurred())
   150  
   151  				Expect(droplet).To(Equal(Droplet{
   152  					GUID:  "some-guid",
   153  					Stack: "some-stack",
   154  					State: constant.DropletStaged,
   155  					Buildpacks: []DropletBuildpack{
   156  						{
   157  							Name:         "some-buildpack",
   158  							DetectOutput: "detected-buildpack",
   159  						},
   160  					},
   161  					Image:     "docker/some-image",
   162  					CreatedAt: "2016-03-28T23:39:34Z",
   163  				}))
   164  				Expect(warnings).To(ConsistOf("warning-1"))
   165  			})
   166  		})
   167  
   168  		When("cloud controller returns an error", func() {
   169  			BeforeEach(func() {
   170  				response := `{
   171  					"errors": [
   172  						{
   173  							"code": 10010,
   174  							"detail": "Droplet not found",
   175  							"title": "CF-ResourceNotFound"
   176  						}
   177  					]
   178  				}`
   179  				server.AppendHandlers(
   180  					CombineHandlers(
   181  						VerifyRequest(http.MethodGet, "/v3/droplets/some-guid"),
   182  						RespondWith(http.StatusNotFound, response, http.Header{"X-Cf-Warnings": {"warning-1"}}),
   183  					),
   184  				)
   185  			})
   186  
   187  			It("returns the error", func() {
   188  				Expect(executeErr).To(MatchError(ccerror.DropletNotFoundError{}))
   189  				Expect(warnings).To(ConsistOf("warning-1"))
   190  			})
   191  		})
   192  	})
   193  
   194  	Describe("GetDroplets", func() {
   195  		var (
   196  			droplets   []Droplet
   197  			warnings   Warnings
   198  			executeErr error
   199  		)
   200  
   201  		JustBeforeEach(func() {
   202  			droplets, warnings, executeErr = client.GetDroplets(
   203  				Query{Key: AppGUIDFilter, Values: []string{"some-app-guid"}},
   204  				Query{Key: PerPage, Values: []string{"2"}},
   205  			)
   206  		})
   207  
   208  		When("the CC returns back droplets", func() {
   209  			BeforeEach(func() {
   210  				response1 := fmt.Sprintf(`{
   211  					"pagination": {
   212  						"next": {
   213  							"href": "%s/v3/droplets?app_guids=some-app-guid&per_page=2&page=2"
   214  						}
   215  					},
   216  					"resources": [
   217  						{
   218  							"guid": "some-guid-1",
   219  							"stack": "some-stack-1",
   220  							"buildpacks": [{
   221  								"name": "some-buildpack-1",
   222  								"detect_output": "detected-buildpack-1"
   223  							}],
   224  							"state": "STAGED",
   225  							"created_at": "2017-08-16T00:18:24Z",
   226  							"links": {
   227  								"package": "https://api.com/v3/packages/some-package-guid"
   228  							}
   229  						},
   230  						{
   231  							"guid": "some-guid-2",
   232  							"stack": "some-stack-2",
   233  							"buildpacks": [{
   234  								"name": "some-buildpack-2",
   235  								"detect_output": "detected-buildpack-2"
   236  							}],
   237  							"state": "COPYING",
   238  							"created_at": "2017-08-16T00:19:05Z"
   239  						}
   240  					]
   241  				}`, server.URL())
   242  				response2 := `{
   243  					"pagination": {
   244  						"next": null
   245  					},
   246  					"resources": [
   247  						{
   248  							"guid": "some-guid-3",
   249  							"stack": "some-stack-3",
   250  							"buildpacks": [{
   251  								"name": "some-buildpack-3",
   252  								"detect_output": "detected-buildpack-3"
   253  							}],
   254  							"state": "FAILED",
   255  							"created_at": "2017-08-22T17:55:02Z"
   256  						}
   257  					]
   258  				}`
   259  				server.AppendHandlers(
   260  					CombineHandlers(
   261  						VerifyRequest(http.MethodGet, "/v3/droplets", "app_guids=some-app-guid&per_page=2"),
   262  						RespondWith(http.StatusOK, response1, http.Header{"X-Cf-Warnings": {"warning-1"}}),
   263  					),
   264  				)
   265  				server.AppendHandlers(
   266  					CombineHandlers(
   267  						VerifyRequest(http.MethodGet, "/v3/droplets", "app_guids=some-app-guid&per_page=2&page=2"),
   268  						RespondWith(http.StatusOK, response2, http.Header{"X-Cf-Warnings": {"warning-2"}}),
   269  					),
   270  				)
   271  			})
   272  
   273  			It("returns the droplets and all warnings", func() {
   274  				Expect(executeErr).ToNot(HaveOccurred())
   275  				Expect(droplets).To(HaveLen(3))
   276  
   277  				Expect(droplets[0]).To(Equal(Droplet{
   278  					GUID:  "some-guid-1",
   279  					Stack: "some-stack-1",
   280  					State: constant.DropletStaged,
   281  					Buildpacks: []DropletBuildpack{
   282  						{
   283  							Name:         "some-buildpack-1",
   284  							DetectOutput: "detected-buildpack-1",
   285  						},
   286  					},
   287  					CreatedAt: "2017-08-16T00:18:24Z",
   288  				}))
   289  				Expect(droplets[1]).To(Equal(Droplet{
   290  					GUID:  "some-guid-2",
   291  					Stack: "some-stack-2",
   292  					State: constant.DropletCopying,
   293  					Buildpacks: []DropletBuildpack{
   294  						{
   295  							Name:         "some-buildpack-2",
   296  							DetectOutput: "detected-buildpack-2",
   297  						},
   298  					},
   299  					CreatedAt: "2017-08-16T00:19:05Z",
   300  				}))
   301  				Expect(droplets[2]).To(Equal(Droplet{
   302  					GUID:  "some-guid-3",
   303  					Stack: "some-stack-3",
   304  					State: constant.DropletFailed,
   305  					Buildpacks: []DropletBuildpack{
   306  						{
   307  							Name:         "some-buildpack-3",
   308  							DetectOutput: "detected-buildpack-3",
   309  						},
   310  					},
   311  					CreatedAt: "2017-08-22T17:55:02Z",
   312  				}))
   313  				Expect(warnings).To(ConsistOf("warning-1", "warning-2"))
   314  			})
   315  		})
   316  
   317  		When("cloud controller returns an error", func() {
   318  			BeforeEach(func() {
   319  				response := `{
   320  					"errors": [
   321  						{
   322  							"code": 10010,
   323  							"detail": "App not found",
   324  							"title": "CF-ResourceNotFound"
   325  						}
   326  					]
   327  				}`
   328  				server.AppendHandlers(
   329  					CombineHandlers(
   330  						VerifyRequest(http.MethodGet, "/v3/droplets", "app_guids=some-app-guid&per_page=2"),
   331  						RespondWith(http.StatusNotFound, response, http.Header{"X-Cf-Warnings": {"warning-1"}}),
   332  					),
   333  				)
   334  			})
   335  
   336  			It("returns the error", func() {
   337  				Expect(executeErr).To(MatchError(ccerror.ApplicationNotFoundError{}))
   338  				Expect(warnings).To(ConsistOf("warning-1"))
   339  			})
   340  		})
   341  	})
   342  })