github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/resource/api/server/server_addpending_test.go (about)

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