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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package application_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/golang/mock/gomock"
    10  	gc "gopkg.in/check.v1"
    11  	charm "gopkg.in/juju/charm.v6"
    12  	charmrepo "gopkg.in/juju/charmrepo.v3"
    13  	"gopkg.in/mgo.v2"
    14  
    15  	"github.com/juju/testing"
    16  
    17  	"github.com/juju/juju/apiserver/facades/client/application"
    18  	"github.com/juju/juju/apiserver/facades/client/application/mocks"
    19  	"github.com/juju/juju/apiserver/params"
    20  	"github.com/juju/juju/state"
    21  	"github.com/juju/juju/state/storage"
    22  	"github.com/juju/juju/testcharms"
    23  )
    24  
    25  type CharmStoreSuite struct {
    26  	testing.IsolationSuite
    27  }
    28  
    29  var _ = gc.Suite(&CharmStoreSuite{})
    30  
    31  func (s *CharmStoreSuite) TestAddCharmWithAuthorization(c *gc.C) {
    32  	ctrl := gomock.NewController(c)
    33  	defer ctrl.Finish()
    34  
    35  	cacheDir := c.MkDir()
    36  	s.PatchValue(&charmrepo.CacheDir, cacheDir)
    37  
    38  	url := "cs:~juju-qa/bionic/lxd-profile-0"
    39  	charmURL, err := charm.ParseURL(url)
    40  	c.Assert(err, gc.IsNil)
    41  
    42  	mockState := mocks.NewMockState(ctrl)
    43  	mockStateCharm := mocks.NewMockStateCharm(ctrl)
    44  	mockStorage := mocks.NewMockStorage(ctrl)
    45  	mockInterface := mocks.NewMockInterface(ctrl)
    46  
    47  	charm := testcharms.Repo.CharmArchive(cacheDir, "lxd-profile")
    48  
    49  	// inject the mock as a back handed dependency
    50  	s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) storage.Storage {
    51  		return mockStorage
    52  	})
    53  
    54  	sExp := mockState.EXPECT()
    55  	sExp.PrepareStoreCharmUpload(charmURL).Return(mockStateCharm, nil)
    56  	sExp.ModelUUID().Return("model-id")
    57  	sExp.MongoSession().Return(&mgo.Session{})
    58  	sExp.UpdateUploadedCharm(gomock.Any()).Return(nil, nil)
    59  
    60  	cExp := mockStateCharm.EXPECT()
    61  	cExp.IsUploaded().Return(false)
    62  
    63  	stExp := mockStorage.EXPECT()
    64  	stExp.Put(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
    65  
    66  	iExp := mockInterface.EXPECT()
    67  	iExp.Get(charmURL).Return(charm, nil)
    68  
    69  	err = application.AddCharmWithAuthorizationAndRepo(mockState, params.AddCharmWithAuthorization{
    70  		URL: url,
    71  	}, func() (charmrepo.Interface, error) {
    72  		return mockInterface, nil
    73  	})
    74  	c.Assert(err, gc.IsNil)
    75  }
    76  
    77  func (s *CharmStoreSuite) TestAddCharmWithAuthorizationWithInvalidLXDProfile(c *gc.C) {
    78  	ctrl := gomock.NewController(c)
    79  	defer ctrl.Finish()
    80  
    81  	cacheDir := c.MkDir()
    82  	s.PatchValue(&charmrepo.CacheDir, cacheDir)
    83  
    84  	url := "cs:~juju-qa/bionic/lxd-profile-fail-0"
    85  	charmURL, err := charm.ParseURL(url)
    86  	c.Assert(err, gc.IsNil)
    87  
    88  	mockState := mocks.NewMockState(ctrl)
    89  	mockStateCharm := mocks.NewMockStateCharm(ctrl)
    90  	mockStorage := mocks.NewMockStorage(ctrl)
    91  	mockInterface := mocks.NewMockInterface(ctrl)
    92  
    93  	charm := testcharms.Repo.CharmArchive(cacheDir, "lxd-profile-fail")
    94  
    95  	// inject the mock as a back handed dependency
    96  	s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) storage.Storage {
    97  		return mockStorage
    98  	})
    99  
   100  	sExp := mockState.EXPECT()
   101  	sExp.PrepareStoreCharmUpload(charmURL).Return(mockStateCharm, nil)
   102  
   103  	cExp := mockStateCharm.EXPECT()
   104  	cExp.IsUploaded().Return(false)
   105  
   106  	iExp := mockInterface.EXPECT()
   107  	iExp.Get(charmURL).Return(charm, nil)
   108  
   109  	err = application.AddCharmWithAuthorizationAndRepo(mockState, params.AddCharmWithAuthorization{
   110  		URL: url,
   111  	}, func() (charmrepo.Interface, error) {
   112  		return mockInterface, nil
   113  	})
   114  	c.Assert(err, gc.ErrorMatches, "cannot add charm: invalid lxd-profile.yaml: contains device type \"unix-disk\"")
   115  }
   116  
   117  func (s *CharmStoreSuite) TestAddCharmWithAuthorizationAndForce(c *gc.C) {
   118  	ctrl := gomock.NewController(c)
   119  	defer ctrl.Finish()
   120  
   121  	cacheDir := c.MkDir()
   122  	s.PatchValue(&charmrepo.CacheDir, cacheDir)
   123  
   124  	url := "cs:~juju-qa/bionic/lxd-profile-0"
   125  	charmURL, err := charm.ParseURL(url)
   126  	c.Assert(err, gc.IsNil)
   127  
   128  	mockState := mocks.NewMockState(ctrl)
   129  	mockStateCharm := mocks.NewMockStateCharm(ctrl)
   130  	mockStorage := mocks.NewMockStorage(ctrl)
   131  	mockInterface := mocks.NewMockInterface(ctrl)
   132  
   133  	charm := testcharms.Repo.CharmArchive(cacheDir, "lxd-profile")
   134  
   135  	// inject the mock as a back handed dependency
   136  	s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) storage.Storage {
   137  		return mockStorage
   138  	})
   139  
   140  	sExp := mockState.EXPECT()
   141  	sExp.PrepareStoreCharmUpload(charmURL).Return(mockStateCharm, nil)
   142  	sExp.ModelUUID().Return("model-id")
   143  	sExp.MongoSession().Return(&mgo.Session{})
   144  	sExp.UpdateUploadedCharm(gomock.Any()).Return(nil, nil)
   145  
   146  	cExp := mockStateCharm.EXPECT()
   147  	cExp.IsUploaded().Return(false)
   148  
   149  	stExp := mockStorage.EXPECT()
   150  	stExp.Put(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
   151  
   152  	iExp := mockInterface.EXPECT()
   153  	iExp.Get(charmURL).Return(charm, nil)
   154  
   155  	err = application.AddCharmWithAuthorizationAndRepo(mockState, params.AddCharmWithAuthorization{
   156  		URL:   url,
   157  		Force: true,
   158  	}, func() (charmrepo.Interface, error) {
   159  		return mockInterface, nil
   160  	})
   161  	c.Assert(err, gc.IsNil)
   162  }
   163  
   164  func (s *CharmStoreSuite) TestAddCharmWithAuthorizationWithInvalidLXDProfileAndForceStilSucceeds(c *gc.C) {
   165  	ctrl := gomock.NewController(c)
   166  	defer ctrl.Finish()
   167  
   168  	cacheDir := c.MkDir()
   169  	s.PatchValue(&charmrepo.CacheDir, cacheDir)
   170  
   171  	url := "cs:~juju-qa/bionic/lxd-profile-fail-0"
   172  	charmURL, err := charm.ParseURL(url)
   173  	c.Assert(err, gc.IsNil)
   174  
   175  	mockState := mocks.NewMockState(ctrl)
   176  	mockStateCharm := mocks.NewMockStateCharm(ctrl)
   177  	mockStorage := mocks.NewMockStorage(ctrl)
   178  	mockInterface := mocks.NewMockInterface(ctrl)
   179  
   180  	charm := testcharms.Repo.CharmArchive(cacheDir, "lxd-profile-fail")
   181  
   182  	// inject the mock as a back handed dependency
   183  	s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) storage.Storage {
   184  		return mockStorage
   185  	})
   186  
   187  	sExp := mockState.EXPECT()
   188  	sExp.PrepareStoreCharmUpload(charmURL).Return(mockStateCharm, nil)
   189  	sExp.ModelUUID().Return("model-id")
   190  	sExp.MongoSession().Return(&mgo.Session{})
   191  	sExp.UpdateUploadedCharm(gomock.Any()).Return(nil, nil)
   192  
   193  	cExp := mockStateCharm.EXPECT()
   194  	cExp.IsUploaded().Return(false)
   195  
   196  	stExp := mockStorage.EXPECT()
   197  	stExp.Put(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
   198  
   199  	iExp := mockInterface.EXPECT()
   200  	iExp.Get(charmURL).Return(charm, nil)
   201  
   202  	err = application.AddCharmWithAuthorizationAndRepo(mockState, params.AddCharmWithAuthorization{
   203  		URL:   url,
   204  		Force: true,
   205  	}, func() (charmrepo.Interface, error) {
   206  		return mockInterface, nil
   207  	})
   208  	c.Assert(err, gc.IsNil)
   209  }
   210  
   211  func (s *CharmStoreSuite) TestAddVersionedCharmWithAuthorization(c *gc.C) {
   212  	ctrl := gomock.NewController(c)
   213  	defer ctrl.Finish()
   214  
   215  	cacheDir := c.MkDir()
   216  	s.PatchValue(&charmrepo.CacheDir, cacheDir)
   217  
   218  	url := "cs:~juju-qa/bionic/versioned-0"
   219  	charmURL, err := charm.ParseURL(url)
   220  	c.Assert(err, gc.IsNil)
   221  
   222  	mockState := mocks.NewMockState(ctrl)
   223  	mockStateCharm := mocks.NewMockStateCharm(ctrl)
   224  	mockStorage := mocks.NewMockStorage(ctrl)
   225  	mockInterface := mocks.NewMockInterface(ctrl)
   226  
   227  	charm := testcharms.Repo.CharmArchive(cacheDir, "versioned")
   228  
   229  	// inject the mock as a back handed dependency
   230  	s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) storage.Storage {
   231  		return mockStorage
   232  	})
   233  
   234  	sExp := mockState.EXPECT()
   235  	sExp.PrepareStoreCharmUpload(charmURL).Return(mockStateCharm, nil)
   236  	sExp.ModelUUID().Return("model-id")
   237  	sExp.MongoSession().Return(&mgo.Session{})
   238  	sExp.UpdateUploadedCharm(charmVersionMatcher{"929903d"}).Return(nil, nil)
   239  
   240  	cExp := mockStateCharm.EXPECT()
   241  	cExp.IsUploaded().Return(false)
   242  
   243  	stExp := mockStorage.EXPECT()
   244  	stExp.Put(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
   245  
   246  	iExp := mockInterface.EXPECT()
   247  	iExp.Get(charmURL).Return(charm, nil)
   248  
   249  	err = application.AddCharmWithAuthorizationAndRepo(mockState, params.AddCharmWithAuthorization{
   250  		URL: url,
   251  	}, func() (charmrepo.Interface, error) {
   252  		return mockInterface, nil
   253  	})
   254  	c.Assert(err, gc.IsNil)
   255  }
   256  
   257  type charmVersionMatcher struct {
   258  	expVersion string
   259  }
   260  
   261  func (m charmVersionMatcher) Matches(x interface{}) bool {
   262  	info, ok := x.(state.CharmInfo)
   263  	if !ok {
   264  		return false
   265  	}
   266  
   267  	return info.Version == m.expVersion
   268  }
   269  
   270  func (m charmVersionMatcher) String() string {
   271  	return fmt.Sprintf("state.CharmInfo.Version == %q", m.expVersion)
   272  }