github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/apiserver/common/controllerconfig_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package common_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/names/v5"
    10  	jc "github.com/juju/testing/checkers"
    11  	"github.com/juju/utils/v3"
    12  	"go.uber.org/mock/gomock"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/apiserver/common"
    16  	"github.com/juju/juju/apiserver/common/mocks"
    17  	"github.com/juju/juju/controller"
    18  	"github.com/juju/juju/core/crossmodel"
    19  	"github.com/juju/juju/core/migration"
    20  	"github.com/juju/juju/core/network"
    21  	jujutesting "github.com/juju/juju/juju/testing"
    22  	"github.com/juju/juju/provider/dummy"
    23  	"github.com/juju/juju/rpc/params"
    24  	"github.com/juju/juju/state"
    25  	"github.com/juju/juju/testing"
    26  	"github.com/juju/juju/testing/factory"
    27  )
    28  
    29  type controllerConfigSuite struct {
    30  	testing.BaseSuite
    31  
    32  	st *mocks.MockControllerConfigState
    33  	cc *common.ControllerConfigAPI
    34  }
    35  
    36  var _ = gc.Suite(&controllerConfigSuite{})
    37  
    38  func (s *controllerConfigSuite) setup(c *gc.C) *gomock.Controller {
    39  	ctrl := gomock.NewController(c)
    40  
    41  	s.st = mocks.NewMockControllerConfigState(ctrl)
    42  	s.cc = common.NewStateControllerConfig(s.st)
    43  	return ctrl
    44  }
    45  
    46  func (s *controllerConfigSuite) TearDownTest(c *gc.C) {
    47  	dummy.Reset(c)
    48  	s.BaseSuite.TearDownTest(c)
    49  }
    50  
    51  func (s *controllerConfigSuite) TestControllerConfigSuccess(c *gc.C) {
    52  	defer s.setup(c).Finish()
    53  
    54  	s.st.EXPECT().ControllerConfig().Return(
    55  		map[string]interface{}{
    56  			controller.ControllerUUIDKey: testing.ControllerTag.Id(),
    57  			controller.CACertKey:         testing.CACert,
    58  			controller.APIPort:           4321,
    59  			controller.StatePort:         1234,
    60  		},
    61  		nil,
    62  	)
    63  
    64  	result, err := s.cc.ControllerConfig()
    65  	c.Assert(err, jc.ErrorIsNil)
    66  	c.Assert(map[string]interface{}(result.Config), jc.DeepEquals, map[string]interface{}{
    67  		"ca-cert":         testing.CACert,
    68  		"controller-uuid": "deadbeef-1bad-500d-9000-4b1d0d06f00d",
    69  		"state-port":      1234,
    70  		"api-port":        4321,
    71  	})
    72  }
    73  
    74  func (s *controllerConfigSuite) TestControllerConfigFetchError(c *gc.C) {
    75  	defer s.setup(c).Finish()
    76  
    77  	s.st.EXPECT().ControllerConfig().Return(nil, fmt.Errorf("pow"))
    78  	_, err := s.cc.ControllerConfig()
    79  	c.Assert(err, gc.ErrorMatches, "pow")
    80  }
    81  
    82  func (s *controllerConfigSuite) expectStateControllerInfo(c *gc.C) {
    83  	s.st.EXPECT().APIHostPortsForAgents().Return([]network.SpaceHostPorts{
    84  		network.NewSpaceHostPorts(17070, "192.168.1.1"),
    85  	}, nil)
    86  	s.st.EXPECT().ControllerConfig().Return(map[string]interface{}{
    87  		controller.CACertKey: testing.CACert,
    88  	}, nil)
    89  }
    90  
    91  func (s *controllerConfigSuite) TestControllerInfo(c *gc.C) {
    92  	defer s.setup(c).Finish()
    93  
    94  	s.st.EXPECT().ModelExists(testing.ModelTag.Id()).Return(true, nil)
    95  	s.expectStateControllerInfo(c)
    96  
    97  	results, err := s.cc.ControllerAPIInfoForModels(params.Entities{
    98  		Entities: []params.Entity{{Tag: testing.ModelTag.String()}}})
    99  	c.Assert(err, jc.ErrorIsNil)
   100  	c.Assert(results.Results, gc.HasLen, 1)
   101  	c.Assert(results.Results[0].Addresses, gc.DeepEquals, []string{"192.168.1.1:17070"})
   102  	c.Assert(results.Results[0].CACert, gc.Equals, testing.CACert)
   103  }
   104  
   105  type controllerInfoSuite struct {
   106  	jujutesting.JujuConnSuite
   107  
   108  	localState *state.State
   109  	localModel *state.Model
   110  }
   111  
   112  var _ = gc.Suite(&controllerInfoSuite{})
   113  
   114  func (s *controllerInfoSuite) SetUpTest(c *gc.C) {
   115  	s.JujuConnSuite.SetUpTest(c)
   116  	s.localState = s.Factory.MakeModel(c, nil)
   117  	s.AddCleanup(func(*gc.C) {
   118  		s.localState.Close()
   119  	})
   120  	model, err := s.localState.Model()
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	s.localModel = model
   123  }
   124  
   125  func (s *controllerInfoSuite) TestControllerInfoLocalModel(c *gc.C) {
   126  	cc := common.NewStateControllerConfig(s.State)
   127  	results, err := cc.ControllerAPIInfoForModels(params.Entities{
   128  		Entities: []params.Entity{{Tag: s.localModel.ModelTag().String()}}})
   129  	c.Assert(err, jc.ErrorIsNil)
   130  	c.Assert(results.Results, gc.HasLen, 1)
   131  	systemState, err := s.StatePool.SystemState()
   132  	c.Assert(err, jc.ErrorIsNil)
   133  	apiAddr, err := systemState.APIHostPortsForClients()
   134  	c.Assert(err, jc.ErrorIsNil)
   135  	c.Assert(results.Results[0].Addresses, gc.HasLen, 1)
   136  	c.Assert(results.Results[0].Addresses[0], gc.Equals, apiAddr[0][0].String())
   137  	c.Assert(results.Results[0].CACert, gc.Equals, testing.CACert)
   138  }
   139  
   140  func (s *controllerInfoSuite) TestControllerInfoExternalModel(c *gc.C) {
   141  	ec := state.NewExternalControllers(s.State)
   142  	modelUUID := utils.MustNewUUID().String()
   143  	info := crossmodel.ControllerInfo{
   144  		ControllerTag: testing.ControllerTag,
   145  		Addrs:         []string{"192.168.1.1:12345"},
   146  		CACert:        testing.CACert,
   147  	}
   148  	_, err := ec.Save(info, modelUUID)
   149  	c.Assert(err, jc.ErrorIsNil)
   150  	cc := common.NewStateControllerConfig(s.State)
   151  	results, err := cc.ControllerAPIInfoForModels(params.Entities{
   152  		Entities: []params.Entity{{Tag: names.NewModelTag(modelUUID).String()}}})
   153  	c.Assert(err, jc.ErrorIsNil)
   154  	c.Assert(results.Results, gc.HasLen, 1)
   155  	c.Assert(results.Results[0].Addresses, gc.DeepEquals, info.Addrs)
   156  	c.Assert(results.Results[0].CACert, gc.Equals, info.CACert)
   157  }
   158  
   159  func (s *controllerInfoSuite) TestControllerInfoMigratedController(c *gc.C) {
   160  	cc := common.NewStateControllerConfig(s.State)
   161  	modelState := s.Factory.MakeModel(c, &factory.ModelParams{})
   162  	model, err := modelState.Model()
   163  	c.Assert(err, jc.ErrorIsNil)
   164  
   165  	targetControllerTag := names.NewControllerTag(utils.MustNewUUID().String())
   166  	defer modelState.Close()
   167  
   168  	// Migrate the model and delete it from the state
   169  	controllerIP := "1.2.3.4:5555"
   170  	mig, err := modelState.CreateMigration(state.MigrationSpec{
   171  		InitiatedBy: names.NewUserTag("admin"),
   172  		TargetInfo: migration.TargetInfo{
   173  			ControllerTag:   targetControllerTag,
   174  			ControllerAlias: "target",
   175  			Addrs:           []string{controllerIP},
   176  			CACert:          "",
   177  			AuthTag:         names.NewUserTag("user2"),
   178  			Password:        "secret",
   179  		},
   180  	})
   181  	c.Assert(err, jc.ErrorIsNil)
   182  	for _, phase := range migration.SuccessfulMigrationPhases() {
   183  		c.Assert(mig.SetPhase(phase), jc.ErrorIsNil)
   184  	}
   185  
   186  	c.Assert(model.Destroy(state.DestroyModelParams{}), jc.ErrorIsNil)
   187  	c.Assert(modelState.RemoveDyingModel(), jc.ErrorIsNil)
   188  
   189  	externalControllerInfo, err := cc.ControllerAPIInfoForModels(params.Entities{
   190  		Entities: []params.Entity{{Tag: names.NewModelTag(model.UUID()).String()}}})
   191  	c.Assert(err, jc.ErrorIsNil)
   192  	c.Assert(len(externalControllerInfo.Results), gc.Equals, 1)
   193  	c.Assert(externalControllerInfo.Results[0].Addresses[0], gc.Equals, controllerIP)
   194  }