github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/common/networkingcommon/networkconfigapi_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package networkingcommon_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/apiserver/common"
    11  	"github.com/juju/juju/apiserver/common/networkingcommon"
    12  	"github.com/juju/juju/apiserver/params"
    13  	apiservertesting "github.com/juju/juju/apiserver/testing"
    14  	"github.com/juju/juju/environs/context"
    15  	jujutesting "github.com/juju/juju/juju/testing"
    16  	"github.com/juju/juju/state"
    17  )
    18  
    19  type networkConfigSuite struct {
    20  	jujutesting.JujuConnSuite
    21  
    22  	machine       *state.Machine
    23  	resources     *common.Resources
    24  	networkconfig *networkingcommon.NetworkConfigAPI
    25  }
    26  
    27  var _ = gc.Suite(&networkConfigSuite{})
    28  
    29  func (s *networkConfigSuite) SetUpTest(c *gc.C) {
    30  	s.JujuConnSuite.SetUpTest(c)
    31  
    32  	var err error
    33  	s.machine, err = s.State.AddMachine("quantal", state.JobHostUnits)
    34  
    35  	c.Assert(err, jc.ErrorIsNil)
    36  
    37  	s.networkconfig = networkingcommon.NewNetworkConfigAPI(
    38  		s.State,
    39  		context.NewCloudCallContext(),
    40  		common.AuthAlways(),
    41  	)
    42  }
    43  
    44  func (s *networkConfigSuite) TestSetObservedNetworkConfig(c *gc.C) {
    45  	devices, err := s.machine.AllLinkLayerDevices()
    46  	c.Assert(err, jc.ErrorIsNil)
    47  	c.Assert(devices, gc.HasLen, 0)
    48  
    49  	err = s.machine.SetInstanceInfo("i-foo", "", "FAKE_NONCE", nil, nil, nil, nil, nil, nil)
    50  	c.Assert(err, jc.ErrorIsNil)
    51  
    52  	observedConfig := []params.NetworkConfig{{
    53  		InterfaceName: "lo",
    54  		InterfaceType: "loopback",
    55  		CIDR:          "127.0.0.0/8",
    56  		Address:       "127.0.0.1",
    57  	}, {
    58  		InterfaceName: "eth0",
    59  		InterfaceType: "ethernet",
    60  		MACAddress:    "aa:bb:cc:dd:ee:f0",
    61  		CIDR:          "0.10.0.0/24",
    62  		Address:       "0.10.0.2",
    63  	}, {
    64  		InterfaceName: "eth1",
    65  		InterfaceType: "ethernet",
    66  		MACAddress:    "aa:bb:cc:dd:ee:f1",
    67  		CIDR:          "0.20.0.0/24",
    68  		Address:       "0.20.0.2",
    69  	}}
    70  	args := params.SetMachineNetworkConfig{
    71  		Tag:    s.machine.Tag().String(),
    72  		Config: observedConfig,
    73  	}
    74  
    75  	err = s.networkconfig.SetObservedNetworkConfig(args)
    76  	c.Assert(err, jc.ErrorIsNil)
    77  
    78  	devices, err = s.machine.AllLinkLayerDevices()
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	c.Assert(devices, gc.HasLen, 3)
    81  
    82  	for _, device := range devices {
    83  		c.Check(device.Name(), gc.Matches, `(lo|eth0|eth1)`)
    84  		c.Check(string(device.Type()), gc.Matches, `(loopback|ethernet)`)
    85  		c.Check(device.MACAddress(), gc.Matches, `(|aa:bb:cc:dd:ee:f0|aa:bb:cc:dd:ee:f1)`)
    86  	}
    87  }
    88  
    89  func (s *networkConfigSuite) TestSetObservedNetworkConfigPermissions(c *gc.C) {
    90  	args := params.SetMachineNetworkConfig{
    91  		Tag:    "machine-1",
    92  		Config: nil,
    93  	}
    94  
    95  	err := s.networkconfig.SetObservedNetworkConfig(args)
    96  	c.Assert(err, gc.ErrorMatches, "permission denied")
    97  }
    98  
    99  func (s *networkConfigSuite) TestSetProviderNetworkConfig(c *gc.C) {
   100  	devices, err := s.machine.AllLinkLayerDevices()
   101  	c.Assert(err, jc.ErrorIsNil)
   102  	c.Assert(devices, gc.HasLen, 0)
   103  
   104  	err = s.machine.SetInstanceInfo("i-foo", "", "FAKE_NONCE", nil, nil, nil, nil, nil, nil)
   105  	c.Assert(err, jc.ErrorIsNil)
   106  
   107  	args := params.Entities{Entities: []params.Entity{
   108  		{Tag: s.machine.Tag().String()},
   109  	}}
   110  
   111  	result, err := s.networkconfig.SetProviderNetworkConfig(args)
   112  	c.Assert(err, jc.ErrorIsNil)
   113  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   114  		Results: []params.ErrorResult{{nil}},
   115  	})
   116  
   117  	devices, err = s.machine.AllLinkLayerDevices()
   118  	c.Assert(err, jc.ErrorIsNil)
   119  	c.Assert(devices, gc.HasLen, 3)
   120  
   121  	for _, device := range devices {
   122  		c.Check(device.Name(), gc.Matches, `eth[0-2]`)
   123  		c.Check(string(device.Type()), gc.Equals, "ethernet")
   124  		c.Check(device.MACAddress(), gc.Matches, `aa:bb:cc:dd:ee:f[0-2]`)
   125  		addrs, err := device.Addresses()
   126  		c.Check(err, jc.ErrorIsNil)
   127  		c.Check(addrs, gc.HasLen, 1)
   128  	}
   129  }
   130  
   131  func (s *networkConfigSuite) TestSetProviderNetworkConfigPermissions(c *gc.C) {
   132  	args := params.Entities{Entities: []params.Entity{
   133  		{Tag: "machine-0"},
   134  		{Tag: "machine-1"},
   135  		{Tag: "machine-42"},
   136  	}}
   137  
   138  	result, err := s.networkconfig.SetProviderNetworkConfig(args)
   139  	c.Assert(err, jc.ErrorIsNil)
   140  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   141  		Results: []params.ErrorResult{
   142  			{Error: apiservertesting.NotProvisionedError(s.machine.Id())},
   143  			{Error: apiservertesting.ErrUnauthorized},
   144  			{Error: apiservertesting.ErrUnauthorized},
   145  		},
   146  	})
   147  }