github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/facades/controller/externalcontrollerupdater/externalcontrollerupdater_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package externalcontrollerupdater_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  	names "gopkg.in/juju/names.v2"
    11  
    12  	"github.com/juju/juju/apiserver/common"
    13  	"github.com/juju/juju/apiserver/facades/controller/externalcontrollerupdater"
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/apiserver/testing"
    16  	"github.com/juju/juju/core/crossmodel"
    17  	coretesting "github.com/juju/juju/testing"
    18  )
    19  
    20  var _ = gc.Suite(&CrossControllerSuite{})
    21  
    22  type CrossControllerSuite struct {
    23  	coretesting.BaseSuite
    24  
    25  	watcher             *mockStringsWatcher
    26  	externalControllers *mockExternalControllers
    27  	resources           *common.Resources
    28  	auth                testing.FakeAuthorizer
    29  	api                 *externalcontrollerupdater.ExternalControllerUpdaterAPI
    30  }
    31  
    32  func (s *CrossControllerSuite) SetUpTest(c *gc.C) {
    33  	s.BaseSuite.SetUpTest(c)
    34  	s.auth = testing.FakeAuthorizer{Controller: true}
    35  	s.resources = common.NewResources()
    36  	s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
    37  	s.watcher = newMockStringsWatcher()
    38  	s.AddCleanup(func(*gc.C) { s.watcher.Stop() })
    39  	s.externalControllers = &mockExternalControllers{
    40  		watcher: s.watcher,
    41  	}
    42  	api, err := externalcontrollerupdater.NewAPI(s.auth, s.resources, s.externalControllers)
    43  	c.Assert(err, jc.ErrorIsNil)
    44  	s.api = api
    45  }
    46  
    47  func (s *CrossControllerSuite) TestNewAPINonController(c *gc.C) {
    48  	s.auth.Controller = false
    49  	_, err := externalcontrollerupdater.NewAPI(s.auth, s.resources, s.externalControllers)
    50  	c.Assert(err, gc.Equals, common.ErrPerm)
    51  }
    52  
    53  func (s *CrossControllerSuite) TestExternalControllerInfo(c *gc.C) {
    54  	s.externalControllers.controllers = append(s.externalControllers.controllers, &mockExternalController{
    55  		id: coretesting.ControllerTag.Id(),
    56  		info: crossmodel.ControllerInfo{
    57  			ControllerTag: coretesting.ControllerTag,
    58  			Alias:         "foo",
    59  			Addrs:         []string{"bar"},
    60  			CACert:        "baz",
    61  		},
    62  	})
    63  
    64  	results, err := s.api.ExternalControllerInfo(params.Entities{
    65  		Entities: []params.Entity{
    66  			{coretesting.ControllerTag.String()},
    67  			{"controller-" + coretesting.ModelTag.Id()},
    68  			{"machine-42"},
    69  		},
    70  	})
    71  	c.Assert(err, jc.ErrorIsNil)
    72  	c.Assert(results, jc.DeepEquals, params.ExternalControllerInfoResults{
    73  		[]params.ExternalControllerInfoResult{{
    74  			Result: &params.ExternalControllerInfo{
    75  				ControllerTag: coretesting.ControllerTag.String(),
    76  				Alias:         "foo",
    77  				Addrs:         []string{"bar"},
    78  				CACert:        "baz",
    79  			},
    80  		}, {
    81  			Error: &params.Error{
    82  				Code:    "not found",
    83  				Message: `external controller "deadbeef-0bad-400d-8000-4b1d0d06f00d" not found`,
    84  			},
    85  		}, {
    86  			Error: &params.Error{Message: `"machine-42" is not a valid controller tag`},
    87  		}},
    88  	})
    89  }
    90  
    91  func (s *CrossControllerSuite) TestSetExternalControllerInfo(c *gc.C) {
    92  	s.externalControllers.controllers = append(s.externalControllers.controllers, &mockExternalController{
    93  		id: coretesting.ControllerTag.Id(),
    94  		info: crossmodel.ControllerInfo{
    95  			ControllerTag: coretesting.ControllerTag,
    96  		},
    97  	})
    98  
    99  	results, err := s.api.SetExternalControllerInfo(params.SetExternalControllersInfoParams{
   100  		[]params.SetExternalControllerInfoParams{{
   101  			params.ExternalControllerInfo{
   102  				ControllerTag: coretesting.ControllerTag.String(),
   103  				Alias:         "foo",
   104  				Addrs:         []string{"bar"},
   105  				CACert:        "baz",
   106  			},
   107  		}, {
   108  			params.ExternalControllerInfo{
   109  				ControllerTag: "controller-" + coretesting.ModelTag.Id(),
   110  				Alias:         "qux",
   111  				Addrs:         []string{"quux"},
   112  				CACert:        "quuz",
   113  			},
   114  		}, {
   115  			params.ExternalControllerInfo{
   116  				ControllerTag: "machine-42",
   117  			},
   118  		}},
   119  	})
   120  	c.Assert(err, jc.ErrorIsNil)
   121  	c.Assert(results, jc.DeepEquals, params.ErrorResults{
   122  		[]params.ErrorResult{
   123  			{nil},
   124  			{nil},
   125  			{Error: &params.Error{Message: `"machine-42" is not a valid controller tag`}},
   126  		},
   127  	})
   128  
   129  	c.Assert(
   130  		s.externalControllers.controllers,
   131  		jc.DeepEquals,
   132  		[]*mockExternalController{{
   133  			id: coretesting.ControllerTag.Id(),
   134  			info: crossmodel.ControllerInfo{
   135  				ControllerTag: coretesting.ControllerTag,
   136  				Alias:         "foo",
   137  				Addrs:         []string{"bar"},
   138  				CACert:        "baz",
   139  			},
   140  		}, {
   141  			id: coretesting.ModelTag.Id(),
   142  			info: crossmodel.ControllerInfo{
   143  				ControllerTag: names.NewControllerTag(coretesting.ModelTag.Id()),
   144  				Alias:         "qux",
   145  				Addrs:         []string{"quux"},
   146  				CACert:        "quuz",
   147  			},
   148  		}},
   149  	)
   150  }
   151  
   152  func (s *CrossControllerSuite) TestWatchExternalControllers(c *gc.C) {
   153  	s.watcher.changes <- []string{"a", "b"} // initial value
   154  	results, err := s.api.WatchExternalControllers()
   155  	c.Assert(err, jc.ErrorIsNil)
   156  	c.Assert(results, jc.DeepEquals, params.StringsWatchResults{
   157  		[]params.StringsWatchResult{{
   158  			StringsWatcherId: "1",
   159  			Changes:          []string{"a", "b"},
   160  		}},
   161  	})
   162  	c.Assert(s.resources.Get("1"), gc.Equals, s.watcher)
   163  }
   164  
   165  func (s *CrossControllerSuite) TestWatchControllerInfoError(c *gc.C) {
   166  	s.watcher.tomb.Kill(errors.New("nope"))
   167  	close(s.watcher.changes)
   168  
   169  	results, err := s.api.WatchExternalControllers()
   170  	c.Assert(err, jc.ErrorIsNil)
   171  	c.Assert(results, jc.DeepEquals, params.StringsWatchResults{
   172  		[]params.StringsWatchResult{{
   173  			Error: &params.Error{Message: "nope"},
   174  		}},
   175  	})
   176  	c.Assert(s.resources.Get("1"), gc.IsNil)
   177  }