github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/agent/format_whitebox_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Copyright 2014 Cloudbase Solutions SRL
     3  // Licensed under the AGPLv3, see LICENCE file for details.
     4  
     5  package agent
     6  
     7  import (
     8  	"os"
     9  	"path/filepath"
    10  	"runtime"
    11  
    12  	"github.com/juju/names"
    13  	jc "github.com/juju/testing/checkers"
    14  	gc "gopkg.in/check.v1"
    15  
    16  	"github.com/juju/juju/apiserver/params"
    17  	"github.com/juju/juju/cloudconfig/cloudinit"
    18  	"github.com/juju/juju/state/multiwatcher"
    19  	"github.com/juju/juju/testing"
    20  	jujuversion "github.com/juju/juju/version"
    21  )
    22  
    23  type formatSuite struct {
    24  	testing.BaseSuite
    25  }
    26  
    27  var _ = gc.Suite(&formatSuite{})
    28  
    29  // The agentParams are used by the specific formatter whitebox tests, and is
    30  // located here for easy reuse.
    31  var agentParams = AgentConfigParams{
    32  	Tag:               names.NewMachineTag("1"),
    33  	UpgradedToVersion: jujuversion.Current,
    34  	Jobs:              []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
    35  	Password:          "sekrit",
    36  	CACert:            "ca cert",
    37  	StateAddresses:    []string{"localhost:1234"},
    38  	APIAddresses:      []string{"localhost:1235"},
    39  	Nonce:             "a nonce",
    40  	PreferIPv6:        false,
    41  	Model:             testing.ModelTag,
    42  }
    43  
    44  func newTestConfig(c *gc.C) *configInternal {
    45  	params := agentParams
    46  	params.Paths.DataDir = c.MkDir()
    47  	params.Paths.LogDir = c.MkDir()
    48  	config, err := NewAgentConfig(params)
    49  	c.Assert(err, jc.ErrorIsNil)
    50  	return config.(*configInternal)
    51  }
    52  
    53  func (*formatSuite) TestWriteCommands(c *gc.C) {
    54  	cloudcfg, err := cloudinit.New("quantal")
    55  	c.Assert(err, jc.ErrorIsNil)
    56  	config := newTestConfig(c)
    57  	commands, err := config.WriteCommands(cloudcfg.ShellRenderer())
    58  	c.Assert(err, jc.ErrorIsNil)
    59  	c.Assert(commands, gc.HasLen, 3)
    60  	c.Assert(commands[0], gc.Matches, `mkdir -p '\S+/agents/machine-1'`)
    61  	c.Assert(commands[1], gc.Matches, `cat > '\S+/agents/machine-1/agent.conf' << 'EOF'\n(.|\n)*\nEOF`)
    62  	c.Assert(commands[2], gc.Matches, `chmod 0600 '\S+/agents/machine-1/agent.conf'`)
    63  }
    64  
    65  func (*formatSuite) TestWindowsWriteCommands(c *gc.C) {
    66  	cloudcfg, err := cloudinit.New("win8")
    67  	c.Assert(err, jc.ErrorIsNil)
    68  	config := newTestConfig(c)
    69  	commands, err := config.WriteCommands(cloudcfg.ShellRenderer())
    70  	c.Assert(err, jc.ErrorIsNil)
    71  	c.Assert(commands, gc.HasLen, 2)
    72  	c.Assert(commands[0], gc.Matches, `mkdir '\S+\\agents\\machine-1'`)
    73  	c.Assert(commands[1], gc.Matches, `Set-Content '\S+/agents/machine-1/agent.conf' @"
    74  (.|\n)*
    75  "@`)
    76  }
    77  
    78  func (*formatSuite) TestWriteAgentConfig(c *gc.C) {
    79  	config := newTestConfig(c)
    80  	err := config.Write()
    81  	c.Assert(err, jc.ErrorIsNil)
    82  
    83  	configPath := ConfigPath(config.DataDir(), config.Tag())
    84  	formatPath := filepath.Join(config.Dir(), "format")
    85  	assertFileExists(c, configPath)
    86  	assertFileNotExist(c, formatPath)
    87  }
    88  
    89  func (*formatSuite) TestRead(c *gc.C) {
    90  	config := newTestConfig(c)
    91  	assertWriteAndRead(c, config)
    92  }
    93  
    94  func (*formatSuite) TestReadWriteStateConfig(c *gc.C) {
    95  	servingInfo := params.StateServingInfo{
    96  		Cert:         "some special cert",
    97  		PrivateKey:   "a special key",
    98  		CAPrivateKey: "ca special key",
    99  		StatePort:    12345,
   100  		APIPort:      23456,
   101  	}
   102  	params := agentParams
   103  	params.Paths.DataDir = c.MkDir()
   104  	params.Values = map[string]string{"foo": "bar", "wibble": "wobble"}
   105  	configInterface, err := NewStateMachineConfig(params, servingInfo)
   106  	c.Assert(err, jc.ErrorIsNil)
   107  	config, ok := configInterface.(*configInternal)
   108  	c.Assert(ok, jc.IsTrue)
   109  
   110  	assertWriteAndRead(c, config)
   111  }
   112  
   113  func assertWriteAndRead(c *gc.C, config *configInternal) {
   114  	err := config.Write()
   115  	c.Assert(err, jc.ErrorIsNil)
   116  	configPath := ConfigPath(config.DataDir(), config.Tag())
   117  	readConfig, err := ReadConfig(configPath)
   118  	c.Assert(err, jc.ErrorIsNil)
   119  	c.Assert(readConfig, jc.DeepEquals, config)
   120  }
   121  
   122  func assertFileExists(c *gc.C, path string) {
   123  	fileInfo, err := os.Stat(path)
   124  	c.Assert(err, jc.ErrorIsNil)
   125  	c.Assert(fileInfo.Mode().IsRegular(), jc.IsTrue)
   126  
   127  	// Windows is not fully POSIX compliant. Chmod() and Chown() have unexpected behavior
   128  	// compared to linux/unix
   129  	if runtime.GOOS != "windows" {
   130  		c.Assert(fileInfo.Mode().Perm(), gc.Equals, os.FileMode(0600))
   131  	}
   132  	c.Assert(fileInfo.Size(), jc.GreaterThan, 0)
   133  }
   134  
   135  func assertFileNotExist(c *gc.C, path string) {
   136  	_, err := os.Stat(path)
   137  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   138  }