func (s *remoteSuite) TestIDLocal(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "",
Cert: s.Cert,
}
id := remote.ID()
c.Check(id, gc.Equals, "local")
}
func (s *remoteSuite) TestIDOkay(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Cert: s.Cert,
}
id := remote.ID()
c.Check(id, gc.Equals, "my-remote")
}
func (s *remoteSuite) TestValidateUnknownProtocol(c *gc.C) {
remote := lxdclient.Remote{
Name: "remote",
Host: "http://somewhere/else",
Protocol: "bogus-protocol",
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *remoteSuite) TestValidateSimplestreamsOkay(c *gc.C) {
remote := lxdclient.Remote{
Name: "remote",
Host: "http://somewhere/else",
Protocol: lxdclient.SimplestreamsProtocol,
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *remoteSuite) TestValidateLocalWithCert(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-local",
Host: "",
Protocol: lxdclient.LXDProtocol,
Cert: &lxdclient.Cert{},
}
err := remote.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *remoteSuite) TestValidateLocalSimplestreamsInvalid(c *gc.C) {
remote := lxdclient.Remote{
Name: "",
Host: "",
Protocol: lxdclient.SimplestreamsProtocol,
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *remoteSuite) TestValidateLocalOkay(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-local",
Host: "",
Protocol: lxdclient.LXDProtocol,
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *remoteSuite) TestValidateOkay(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: s.Cert,
}
err := remote.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *remoteSuite) TestValidateLocalMissingName(c *gc.C) {
remote := lxdclient.Remote{
Name: "",
Host: "",
Protocol: lxdclient.LXDProtocol,
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *remoteSuite) TestUsingTCPNoop(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: s.Cert,
}
nonlocal, err := remote.UsingTCP()
c.Assert(err, jc.ErrorIsNil)
c.Check(nonlocal, jc.DeepEquals, remote)
}
func (s *remoteSuite) TestWithDefaultsMissingName(c *gc.C) {
remote := lxdclient.Remote{
Name: "",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: s.Cert,
}
updated, err := remote.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, remote) // Name is not updated.
}
func (s *remoteSuite) TestValidateMissingCert(c *gc.C) {
// We can have "public" remotes that don't require a client certificate
// to connect to and get images from.
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: nil,
}
err := remote.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *remoteSuite) TestWithDefaultsNoop(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: s.Cert,
}
updated, err := remote.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
err = updated.Validate()
c.Check(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, remote)
}
func (s *remoteSuite) TestWithDefaultsZeroValue(c *gc.C) {
var remote lxdclient.Remote
updated, err := remote.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
err = updated.Validate()
c.Check(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, lxdclient.Remote{
Name: "local",
Host: "",
Protocol: lxdclient.LXDProtocol,
Cert: nil,
})
}
func (s *remoteSuite) TestWithDefaultsMissingProtocol(c *gc.C) {
remote := lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Cert: s.Cert,
}
updated, err := remote.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
err = updated.Validate()
c.Check(err, jc.ErrorIsNil)
c.Assert(updated.Cert, gc.NotNil)
c.Check(updated.Cert.Validate(), jc.ErrorIsNil)
updated.Cert = nil // Validate ensured that the cert was okay.
c.Check(updated, jc.DeepEquals, lxdclient.Remote{
Name: "my-remote",
Host: "some-host",
Protocol: lxdclient.LXDProtocol,
Cert: nil,
})
}
func (s *remoteFunctionalSuite) TestUsingTCP(c *gc.C) {
if _, err := net.InterfaceByName(lxdclient.DefaultLXDBridge); err != nil {
c.Skip("network bridge interface not found")
}
lxdclient.PatchGenerateCertificate(&s.CleanupSuite, testingCert, testingKey)
remote := lxdclient.Remote{
Name: "my-remote",
Host: "",
Cert: nil,
}
nonlocal, err := remote.UsingTCP()
c.Assert(err, jc.ErrorIsNil)
checkValidRemote(c, &nonlocal)
c.Check(nonlocal, jc.DeepEquals, lxdclient.Remote{
Name: "my-remote",
Host: nonlocal.Host,
Protocol: lxdclient.LXDProtocol,
Cert: nonlocal.Cert,
})
}
// clientConfig builds a LXD Config based on the env config and returns it.
func (c *environConfig) clientConfig() (lxdclient.Config, error) {
remote := lxdclient.Remote{
Name: "juju-remote",
Host: c.remoteURL(),
ServerPEMCert: c.serverPEMCert(),
}
if c.clientCert() != "" {
certPEM := []byte(c.clientCert())
keyPEM := []byte(c.clientKey())
cert := lxdclient.NewCert(certPEM, keyPEM)
cert.Name = fmt.Sprintf("juju cert for env %q", c.Name())
remote.Cert = &cert
}
cfg := lxdclient.Config{
Namespace: c.namespace(),
Remote: remote,
}
cfg, err := cfg.WithDefaults()
if err != nil {
return cfg, errors.Trace(err)
}
return cfg, nil
}
func (s *remoteSuite) TestValidateZeroValue(c *gc.C) {
var remote lxdclient.Remote
err := remote.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
