github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/facades/client/resources/server_addpending_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package resources_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  	charmresource "gopkg.in/juju/charm.v6/resource"
    11  
    12  	"github.com/juju/juju/apiserver/facades/client/resources"
    13  	"github.com/juju/juju/apiserver/params"
    14  )
    15  
    16  var _ = gc.Suite(&AddPendingResourcesSuite{})
    17  
    18  type AddPendingResourcesSuite struct {
    19  	BaseSuite
    20  }
    21  
    22  func (s *AddPendingResourcesSuite) TestNoURL(c *gc.C) {
    23  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
    24  	id1 := "some-unique-ID"
    25  	s.data.ReturnAddPendingResource = id1
    26  	facade, err := resources.NewFacade(s.data, s.newCSClient)
    27  	c.Assert(err, jc.ErrorIsNil)
    28  
    29  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
    30  		Entity: params.Entity{
    31  			Tag: "application-a-application",
    32  		},
    33  		Resources: []params.CharmResource{
    34  			apiRes1.CharmResource,
    35  		},
    36  	})
    37  	c.Assert(err, jc.ErrorIsNil)
    38  
    39  	s.stub.CheckCallNames(c, "AddPendingResource")
    40  	s.stub.CheckCall(c, 0, "AddPendingResource", "a-application", "", res1.Resource)
    41  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
    42  		PendingIDs: []string{
    43  			id1,
    44  		},
    45  	})
    46  }
    47  
    48  func (s *AddPendingResourcesSuite) TestWithURLUpToDate(c *gc.C) {
    49  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
    50  	res1.Origin = charmresource.OriginStore
    51  	res1.Revision = 3
    52  	apiRes1.Origin = charmresource.OriginStore.String()
    53  	apiRes1.Revision = 3
    54  	id1 := "some-unique-ID"
    55  	s.data.ReturnAddPendingResource = id1
    56  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
    57  		res1.Resource,
    58  	}}
    59  	facade, err := resources.NewFacade(s.data, s.newCSClient)
    60  	c.Assert(err, jc.ErrorIsNil)
    61  
    62  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
    63  		Entity: params.Entity{
    64  			Tag: "application-a-application",
    65  		},
    66  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
    67  			URL: "cs:~a-user/trusty/spam-5",
    68  		},
    69  		Resources: []params.CharmResource{
    70  			apiRes1.CharmResource,
    71  		},
    72  	})
    73  	c.Assert(err, jc.ErrorIsNil)
    74  	c.Assert(result.Error, gc.IsNil)
    75  
    76  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
    77  	s.stub.CheckCall(c, 2, "AddPendingResource", "a-application", "", res1.Resource)
    78  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
    79  		PendingIDs: []string{
    80  			id1,
    81  		},
    82  	})
    83  }
    84  
    85  func (s *AddPendingResourcesSuite) TestWithURLMismatchComplete(c *gc.C) {
    86  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
    87  	res1.Origin = charmresource.OriginStore
    88  	res1.Revision = 3
    89  	apiRes1.Origin = charmresource.OriginStore.String()
    90  	apiRes1.Revision = 3
    91  	id1 := "some-unique-ID"
    92  	s.data.ReturnAddPendingResource = id1
    93  	csRes := res1 // a copy
    94  	csRes.Revision = 2
    95  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
    96  		csRes.Resource,
    97  	}}
    98  	facade, err := resources.NewFacade(s.data, s.newCSClient)
    99  	c.Assert(err, jc.ErrorIsNil)
   100  
   101  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   102  		Entity: params.Entity{
   103  			Tag: "application-a-application",
   104  		},
   105  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   106  			URL: "cs:~a-user/trusty/spam-5",
   107  		},
   108  		Resources: []params.CharmResource{
   109  			apiRes1.CharmResource,
   110  		},
   111  	})
   112  	c.Assert(err, jc.ErrorIsNil)
   113  	c.Assert(result.Error, gc.IsNil)
   114  
   115  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
   116  	s.stub.CheckCall(c, 2, "AddPendingResource", "a-application", "", res1.Resource)
   117  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   118  		PendingIDs: []string{
   119  			id1,
   120  		},
   121  	})
   122  }
   123  
   124  func (s *AddPendingResourcesSuite) TestWithURLMismatchIncomplete(c *gc.C) {
   125  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   126  	res1.Origin = charmresource.OriginStore
   127  	res1.Revision = 2
   128  	apiRes1.Origin = charmresource.OriginStore.String()
   129  	apiRes1.Revision = 3
   130  	apiRes1.Fingerprint = nil
   131  	apiRes1.Size = 0
   132  	id1 := "some-unique-ID"
   133  	s.data.ReturnAddPendingResource = id1
   134  	csRes := res1 // a copy
   135  	csRes.Revision = 2
   136  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
   137  		csRes.Resource,
   138  	}}
   139  	expected := charmresource.Resource{
   140  		Meta:        csRes.Meta,
   141  		Origin:      charmresource.OriginStore,
   142  		Revision:    3,
   143  		Fingerprint: res1.Fingerprint,
   144  		Size:        res1.Size,
   145  	}
   146  	s.csClient.ReturnResourceInfo = &expected
   147  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   148  	c.Assert(err, jc.ErrorIsNil)
   149  
   150  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   151  		Entity: params.Entity{
   152  			Tag: "application-a-application",
   153  		},
   154  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   155  			URL: "cs:~a-user/trusty/spam-5",
   156  		},
   157  		Resources: []params.CharmResource{
   158  			apiRes1.CharmResource,
   159  		},
   160  	})
   161  	c.Assert(err, jc.ErrorIsNil)
   162  
   163  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "ResourceInfo", "AddPendingResource")
   164  	s.stub.CheckCall(c, 3, "AddPendingResource", "a-application", "", expected)
   165  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   166  		PendingIDs: []string{
   167  			id1,
   168  		},
   169  	})
   170  }
   171  
   172  func (s *AddPendingResourcesSuite) TestWithURLNoRevision(c *gc.C) {
   173  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   174  	res1.Origin = charmresource.OriginStore
   175  	res1.Revision = 3
   176  	res1.Size = 10
   177  	apiRes1.Origin = charmresource.OriginStore.String()
   178  	apiRes1.Revision = -1
   179  	apiRes1.Size = 0
   180  	apiRes1.Fingerprint = nil
   181  	id1 := "some-unique-ID"
   182  	s.data.ReturnAddPendingResource = id1
   183  	csRes := res1 // a copy
   184  	csRes.Revision = 3
   185  	csRes.Size = 10
   186  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
   187  		csRes.Resource,
   188  	}}
   189  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   190  	c.Assert(err, jc.ErrorIsNil)
   191  
   192  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   193  		Entity: params.Entity{
   194  			Tag: "application-a-application",
   195  		},
   196  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   197  			URL: "cs:~a-user/trusty/spam-5",
   198  		},
   199  		Resources: []params.CharmResource{
   200  			apiRes1.CharmResource,
   201  		},
   202  	})
   203  	c.Assert(err, jc.ErrorIsNil)
   204  	c.Assert(result.Error, gc.IsNil)
   205  
   206  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
   207  	s.stub.CheckCall(c, 2, "AddPendingResource", "a-application", "", res1.Resource)
   208  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   209  		PendingIDs: []string{
   210  			id1,
   211  		},
   212  	})
   213  }
   214  
   215  func (s *AddPendingResourcesSuite) TestLocalCharm(c *gc.C) {
   216  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   217  	expected := charmresource.Resource{
   218  		Meta:   res1.Meta,
   219  		Origin: charmresource.OriginUpload,
   220  	}
   221  	apiRes1.Origin = charmresource.OriginStore.String()
   222  	apiRes1.Revision = 3
   223  	id1 := "some-unique-ID"
   224  	s.data.ReturnAddPendingResource = id1
   225  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   226  	c.Assert(err, jc.ErrorIsNil)
   227  
   228  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   229  		Entity: params.Entity{
   230  			Tag: "application-a-application",
   231  		},
   232  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   233  			URL: "local:trusty/spam",
   234  		},
   235  		Resources: []params.CharmResource{
   236  			apiRes1.CharmResource,
   237  		},
   238  	})
   239  	c.Assert(err, jc.ErrorIsNil)
   240  	c.Assert(result.Error, gc.IsNil)
   241  
   242  	s.stub.CheckCallNames(c, "AddPendingResource")
   243  	s.stub.CheckCall(c, 0, "AddPendingResource", "a-application", "", expected)
   244  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   245  		PendingIDs: []string{
   246  			id1,
   247  		},
   248  	})
   249  }
   250  
   251  func (s *AddPendingResourcesSuite) TestWithURLUpload(c *gc.C) {
   252  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   253  	res1.Origin = charmresource.OriginUpload
   254  	res1.Revision = 0
   255  	apiRes1.Origin = charmresource.OriginUpload.String()
   256  	apiRes1.Revision = 0
   257  	id1 := "some-unique-ID"
   258  	s.data.ReturnAddPendingResource = id1
   259  	csRes := res1 // a copy
   260  	csRes.Origin = charmresource.OriginStore
   261  	csRes.Revision = 3
   262  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
   263  		csRes.Resource,
   264  	}}
   265  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   266  	c.Assert(err, jc.ErrorIsNil)
   267  
   268  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   269  		Entity: params.Entity{
   270  			Tag: "application-a-application",
   271  		},
   272  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   273  			URL: "cs:~a-user/trusty/spam-5",
   274  		},
   275  		Resources: []params.CharmResource{
   276  			apiRes1.CharmResource,
   277  		},
   278  	})
   279  	c.Assert(err, jc.ErrorIsNil)
   280  	c.Assert(result.Error, gc.IsNil)
   281  
   282  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
   283  	s.stub.CheckCall(c, 2, "AddPendingResource", "a-application", "", res1.Resource)
   284  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   285  		PendingIDs: []string{
   286  			id1,
   287  		},
   288  	})
   289  }
   290  
   291  func (s *AddPendingResourcesSuite) TestUnknownResource(c *gc.C) {
   292  	res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   293  	res1.Origin = charmresource.OriginStore
   294  	res1.Revision = 3
   295  	apiRes1.Origin = charmresource.OriginStore.String()
   296  	apiRes1.Revision = 3
   297  	id1 := "some-unique-ID"
   298  	s.data.ReturnAddPendingResource = id1
   299  	s.csClient.ReturnListResources = [][]charmresource.Resource{{
   300  		res1.Resource,
   301  	}}
   302  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   303  	c.Assert(err, jc.ErrorIsNil)
   304  
   305  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   306  		Entity: params.Entity{
   307  			Tag: "application-a-application",
   308  		},
   309  		AddCharmWithAuthorization: params.AddCharmWithAuthorization{
   310  			URL: "cs:~a-user/trusty/spam-5",
   311  		},
   312  		Resources: []params.CharmResource{
   313  			apiRes1.CharmResource,
   314  		},
   315  	})
   316  	c.Assert(err, jc.ErrorIsNil)
   317  
   318  	s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
   319  	s.stub.CheckCall(c, 2, "AddPendingResource", "a-application", "", res1.Resource)
   320  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   321  		PendingIDs: []string{
   322  			id1,
   323  		},
   324  	})
   325  }
   326  
   327  func (s *AddPendingResourcesSuite) TestDataStoreError(c *gc.C) {
   328  	_, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
   329  	failure := errors.New("<failure>")
   330  	s.stub.SetErrors(failure)
   331  	facade, err := resources.NewFacade(s.data, s.newCSClient)
   332  	c.Assert(err, jc.ErrorIsNil)
   333  
   334  	result, err := facade.AddPendingResources(params.AddPendingResourcesArgs{
   335  		Entity: params.Entity{
   336  			Tag: "application-a-application",
   337  		},
   338  		Resources: []params.CharmResource{
   339  			apiRes1.CharmResource,
   340  		},
   341  	})
   342  	c.Assert(err, jc.ErrorIsNil)
   343  
   344  	s.stub.CheckCallNames(c, "AddPendingResource")
   345  	c.Check(result, jc.DeepEquals, params.AddPendingResourcesResult{
   346  		ErrorResult: params.ErrorResult{Error: &params.Error{
   347  			Message: `while adding pending resource info for "spam": <failure>`,
   348  		}},
   349  	})
   350  }