github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/provider/lxd/provider_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  // +build go1.3
     5  
     6  package lxd_test
     7  
     8  import (
     9  	"fmt"
    10  
    11  	jc "github.com/juju/testing/checkers"
    12  	"github.com/juju/utils/series"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/cloud"
    16  	"github.com/juju/juju/environs"
    17  	"github.com/juju/juju/provider/lxd"
    18  	"github.com/juju/juju/provider/lxd/lxdnames"
    19  	"github.com/juju/juju/tools/lxdclient"
    20  )
    21  
    22  // This is a quick hack to make wily pass with it's default, but unsupported,
    23  // version of LXD. Wily is supported until 2016-7-??. AFAIU LXD will not be
    24  // backported to wily... so we have this:|
    25  // TODO(redir): Remove after wiley or in yakkety.
    26  func skipIfWily(c *gc.C) {
    27  	if series.HostSeries() == "wily" {
    28  		cfg, _ := lxdclient.Config{}.WithDefaults()
    29  		_, err := lxdclient.Connect(cfg, false)
    30  		// We try to create a client here. On wily this should fail, because
    31  		// the default 0.20 lxd version should make juju/tools/lxdclient return
    32  		// an error.
    33  		if err != nil {
    34  			c.Skip(fmt.Sprintf("Skipping LXD tests because %s", err))
    35  		}
    36  	}
    37  }
    38  
    39  var (
    40  	_ = gc.Suite(&providerSuite{})
    41  	_ = gc.Suite(&ProviderFunctionalSuite{})
    42  )
    43  
    44  type providerSuite struct {
    45  	lxd.BaseSuite
    46  
    47  	provider environs.EnvironProvider
    48  }
    49  
    50  func (s *providerSuite) SetUpTest(c *gc.C) {
    51  	s.BaseSuite.SetUpTest(c)
    52  
    53  	provider, err := environs.Provider("lxd")
    54  	c.Assert(err, jc.ErrorIsNil)
    55  	s.provider = provider
    56  }
    57  
    58  func (s *providerSuite) TestDetectRegions(c *gc.C) {
    59  	c.Assert(s.provider, gc.Implements, new(environs.CloudRegionDetector))
    60  	regions, err := s.provider.(environs.CloudRegionDetector).DetectRegions()
    61  	c.Assert(err, jc.ErrorIsNil)
    62  	c.Assert(regions, jc.DeepEquals, []cloud.Region{{Name: lxdnames.DefaultRegion}})
    63  }
    64  
    65  func (s *providerSuite) TestRegistered(c *gc.C) {
    66  	c.Check(s.provider, gc.Equals, lxd.Provider)
    67  }
    68  
    69  func (s *providerSuite) TestValidate(c *gc.C) {
    70  	validCfg, err := s.provider.Validate(s.Config, nil)
    71  	c.Assert(err, jc.ErrorIsNil)
    72  	validAttrs := validCfg.AllAttrs()
    73  
    74  	c.Check(s.Config.AllAttrs(), gc.DeepEquals, validAttrs)
    75  }
    76  
    77  type ProviderFunctionalSuite struct {
    78  	lxd.BaseSuite
    79  
    80  	provider environs.EnvironProvider
    81  }
    82  
    83  func (s *ProviderFunctionalSuite) SetUpTest(c *gc.C) {
    84  	if !s.IsRunningLocally(c) {
    85  		c.Skip("LXD not running locally")
    86  	}
    87  
    88  	// TODO(redir): Remove after wily or in yakkety.
    89  	skipIfWily(c)
    90  
    91  	s.BaseSuite.SetUpTest(c)
    92  
    93  	provider, err := environs.Provider("lxd")
    94  	c.Assert(err, jc.ErrorIsNil)
    95  
    96  	s.provider = provider
    97  }
    98  
    99  func (s *ProviderFunctionalSuite) TestOpen(c *gc.C) {
   100  	env, err := s.provider.Open(environs.OpenParams{
   101  		Cloud:  lxdCloudSpec(),
   102  		Config: s.Config,
   103  	})
   104  	c.Assert(err, jc.ErrorIsNil)
   105  	envConfig := env.Config()
   106  
   107  	c.Check(envConfig.Name(), gc.Equals, "testenv")
   108  }
   109  
   110  func (s *ProviderFunctionalSuite) TestPrepareConfig(c *gc.C) {
   111  	cfg, err := s.provider.PrepareConfig(environs.PrepareConfigParams{
   112  		Cloud:  lxdCloudSpec(),
   113  		Config: s.Config,
   114  	})
   115  	c.Assert(err, jc.ErrorIsNil)
   116  	c.Check(cfg, gc.NotNil)
   117  }
   118  
   119  func (s *ProviderFunctionalSuite) TestPrepareConfigUnsupportedAuthType(c *gc.C) {
   120  	cred := cloud.NewCredential(cloud.CertificateAuthType, nil)
   121  	_, err := s.provider.PrepareConfig(environs.PrepareConfigParams{
   122  		Cloud: environs.CloudSpec{
   123  			Type:       "lxd",
   124  			Name:       "remotehost",
   125  			Credential: &cred,
   126  		},
   127  	})
   128  	c.Assert(err, gc.ErrorMatches, `validating cloud spec: "certificate" auth-type not supported`)
   129  }
   130  
   131  func (s *ProviderFunctionalSuite) TestPrepareConfigNonEmptyEndpoint(c *gc.C) {
   132  	_, err := s.provider.PrepareConfig(environs.PrepareConfigParams{
   133  		Cloud: environs.CloudSpec{
   134  			Type:     "lxd",
   135  			Name:     "remotehost",
   136  			Endpoint: "1.2.3.4",
   137  		},
   138  	})
   139  	c.Assert(err, gc.ErrorMatches, `validating cloud spec: non-empty endpoint "1.2.3.4" not valid`)
   140  }