github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/api/client/applicationoffers/access_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package applicationoffers_test
     5  
     6  import (
     7  	"github.com/juju/names/v5"
     8  	jc "github.com/juju/testing/checkers"
     9  	"go.uber.org/mock/gomock"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	basemocks "github.com/juju/juju/api/base/mocks"
    13  	"github.com/juju/juju/api/client/applicationoffers"
    14  	"github.com/juju/juju/rpc/params"
    15  )
    16  
    17  type accessSuite struct {
    18  }
    19  
    20  var _ = gc.Suite(&accessSuite{})
    21  
    22  const (
    23  	someOffer = "user/prod.hosted-mysql"
    24  )
    25  
    26  func accessCall(client *applicationoffers.Client, action params.OfferAction, user, access string, offerURLs ...string) error {
    27  	switch action {
    28  	case params.GrantOfferAccess:
    29  		return client.GrantOffer(user, access, offerURLs...)
    30  	case params.RevokeOfferAccess:
    31  		return client.RevokeOffer(user, access, offerURLs...)
    32  	default:
    33  		panic(action)
    34  	}
    35  }
    36  
    37  func (s *accessSuite) TestGrantOfferReadOnlyUser(c *gc.C) {
    38  	s.readOnlyUser(c, params.GrantOfferAccess)
    39  }
    40  
    41  func (s *accessSuite) TestRevokeOfferReadOnlyUser(c *gc.C) {
    42  	s.readOnlyUser(c, params.RevokeOfferAccess)
    43  }
    44  
    45  func (s *accessSuite) readOnlyUser(c *gc.C, action params.OfferAction) {
    46  	ctrl := gomock.NewController(c)
    47  	defer ctrl.Finish()
    48  
    49  	args := params.ModifyOfferAccessRequest{
    50  		Changes: []params.ModifyOfferAccess{
    51  			{
    52  				UserTag:  names.NewUserTag("bob").String(),
    53  				Action:   action,
    54  				Access:   params.OfferReadAccess,
    55  				OfferURL: someOffer,
    56  			},
    57  		},
    58  	}
    59  
    60  	res := new(params.ErrorResults)
    61  	ress := params.ErrorResults{Results: []params.ErrorResult{{Error: nil}}}
    62  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
    63  	mockFacadeCaller.EXPECT().FacadeCall("ModifyOfferAccess", args, res).SetArg(2, ress).Return(nil)
    64  
    65  	client := applicationoffers.NewClientFromCaller(mockFacadeCaller)
    66  
    67  	err := accessCall(client, action, "bob", "read", someOffer)
    68  	c.Assert(err, jc.ErrorIsNil)
    69  }
    70  
    71  func (s *accessSuite) TestGrantOfferAdminUser(c *gc.C) {
    72  	s.adminUser(c, params.GrantOfferAccess)
    73  }
    74  
    75  func (s *accessSuite) TestRevokeOfferAdminUser(c *gc.C) {
    76  	s.adminUser(c, params.RevokeOfferAccess)
    77  }
    78  
    79  func (s *accessSuite) adminUser(c *gc.C, action params.OfferAction) {
    80  	ctrl := gomock.NewController(c)
    81  	defer ctrl.Finish()
    82  
    83  	args := params.ModifyOfferAccessRequest{
    84  		Changes: []params.ModifyOfferAccess{
    85  			{
    86  				UserTag:  names.NewUserTag("bob").String(),
    87  				Action:   action,
    88  				Access:   params.OfferConsumeAccess,
    89  				OfferURL: someOffer,
    90  			},
    91  		},
    92  	}
    93  
    94  	res := new(params.ErrorResults)
    95  	ress := params.ErrorResults{Results: []params.ErrorResult{{Error: nil}}}
    96  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
    97  	mockFacadeCaller.EXPECT().FacadeCall("ModifyOfferAccess", args, res).SetArg(2, ress).Return(nil)
    98  
    99  	client := applicationoffers.NewClientFromCaller(mockFacadeCaller)
   100  	err := accessCall(client, action, "bob", "consume", someOffer)
   101  	c.Assert(err, jc.ErrorIsNil)
   102  }
   103  
   104  func (s *accessSuite) TestGrantThreeOffers(c *gc.C) {
   105  	s.threeOffers(c, params.GrantOfferAccess)
   106  }
   107  
   108  func (s *accessSuite) TestRevokeThreeOffers(c *gc.C) {
   109  	s.threeOffers(c, params.RevokeOfferAccess)
   110  }
   111  
   112  func (s *accessSuite) threeOffers(c *gc.C, action params.OfferAction) {
   113  	ctrl := gomock.NewController(c)
   114  	defer ctrl.Finish()
   115  
   116  	args := params.ModifyOfferAccessRequest{
   117  		Changes: []params.ModifyOfferAccess{
   118  			{
   119  				UserTag:  names.NewUserTag("carol").String(),
   120  				Action:   action,
   121  				Access:   params.OfferReadAccess,
   122  				OfferURL: someOffer,
   123  			},
   124  			{
   125  				UserTag:  names.NewUserTag("carol").String(),
   126  				Action:   action,
   127  				Access:   params.OfferReadAccess,
   128  				OfferURL: someOffer,
   129  			},
   130  			{
   131  				UserTag:  names.NewUserTag("carol").String(),
   132  				Action:   action,
   133  				Access:   params.OfferReadAccess,
   134  				OfferURL: someOffer,
   135  			},
   136  		},
   137  	}
   138  
   139  	res := new(params.ErrorResults)
   140  	ress := params.ErrorResults{Results: []params.ErrorResult{{Error: nil}, {Error: nil}, {Error: nil}}}
   141  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
   142  	mockFacadeCaller.EXPECT().FacadeCall("ModifyOfferAccess", args, res).SetArg(2, ress).Return(nil)
   143  
   144  	client := applicationoffers.NewClientFromCaller(mockFacadeCaller)
   145  	err := accessCall(client, action, "carol", "read", someOffer, someOffer, someOffer)
   146  	c.Assert(err, jc.ErrorIsNil)
   147  }
   148  
   149  func (s *accessSuite) TestGrantErrorResult(c *gc.C) {
   150  	s.errorResult(c, params.GrantOfferAccess)
   151  }
   152  
   153  func (s *accessSuite) TestRevokeErrorResult(c *gc.C) {
   154  	s.errorResult(c, params.RevokeOfferAccess)
   155  }
   156  
   157  func (s *accessSuite) errorResult(c *gc.C, action params.OfferAction) {
   158  	ctrl := gomock.NewController(c)
   159  	defer ctrl.Finish()
   160  
   161  	args := params.ModifyOfferAccessRequest{
   162  		Changes: []params.ModifyOfferAccess{
   163  			{
   164  				UserTag:  names.NewUserTag("aaa").String(),
   165  				Action:   action,
   166  				Access:   params.OfferConsumeAccess,
   167  				OfferURL: someOffer,
   168  			},
   169  		},
   170  	}
   171  
   172  	res := new(params.ErrorResults)
   173  	ress := params.ErrorResults{Results: []params.ErrorResult{{Error: &params.Error{Message: "unfortunate mishap"}}}}
   174  
   175  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
   176  	mockFacadeCaller.EXPECT().FacadeCall("ModifyOfferAccess", args, res).SetArg(2, ress).Return(nil)
   177  	client := applicationoffers.NewClientFromCaller(mockFacadeCaller)
   178  
   179  	err := accessCall(client, action, "aaa", "consume", someOffer)
   180  	c.Assert(err, gc.ErrorMatches, "unfortunate mishap")
   181  }
   182  
   183  func (s *accessSuite) TestInvalidResultCount(c *gc.C) {
   184  	ctrl := gomock.NewController(c)
   185  	defer ctrl.Finish()
   186  
   187  	args := params.ModifyOfferAccessRequest{
   188  		Changes: []params.ModifyOfferAccess{
   189  			{
   190  				UserTag:  names.NewUserTag("bob").String(),
   191  				Action:   params.GrantOfferAccess,
   192  				Access:   params.OfferConsumeAccess,
   193  				OfferURL: someOffer,
   194  			},
   195  			{
   196  				UserTag:  names.NewUserTag("bob").String(),
   197  				Action:   params.GrantOfferAccess,
   198  				Access:   params.OfferConsumeAccess,
   199  				OfferURL: someOffer,
   200  			},
   201  		},
   202  	}
   203  
   204  	res := new(params.ErrorResults)
   205  	ress := params.ErrorResults{Results: nil}
   206  	mockFacadeCaller := basemocks.NewMockFacadeCaller(ctrl)
   207  	mockFacadeCaller.EXPECT().FacadeCall("ModifyOfferAccess", args, res).SetArg(2, ress).Return(nil)
   208  	client := applicationoffers.NewClientFromCaller(mockFacadeCaller)
   209  
   210  	err := client.GrantOffer("bob", "consume", someOffer, someOffer)
   211  	c.Assert(err, gc.ErrorMatches, "expected 2 results, got 0")
   212  }