func (s *configFunctionalSuite) TestUsingTCPRemote(c *gc.C) {
if s.client == nil {
c.Skip("LXD not running locally")
}
// We can't just pass the testingCert as part of the Local connection,
// because Validate() doesn't like Local remotes that have
// Certificates.
lxdclient.PatchGenerateCertificate(&s.CleanupSuite, testingCert, testingKey)
cfg := lxdclient.Config{
Namespace: "my-ns",
Remote: lxdclient.Local,
}
nonlocal, err := cfg.UsingTCPRemote()
c.Assert(err, jc.ErrorIsNil)
checkValidRemote(c, &nonlocal.Remote)
c.Check(nonlocal, jc.DeepEquals, lxdclient.Config{
Namespace: "my-ns",
Remote: lxdclient.Remote{
Name: lxdclient.Local.Name,
Host: nonlocal.Remote.Host,
Cert: nonlocal.Remote.Cert,
Protocol: lxdclient.LXDProtocol,
ServerPEMCert: nonlocal.Remote.ServerPEMCert,
},
})
c.Check(nonlocal.Remote.Host, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.Cert.CertPEM, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.Cert.KeyPEM, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.ServerPEMCert, gc.Not(gc.Equals), "")
// TODO(ericsnow) Check that the server has the certs.
}
func (s *charmsSuite) SetUpSuite(c *gc.C) {
// TODO(bogdanteleaga): Fix this on windows
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Skipping this on windows for now")
}
s.charmsCommonSuite.SetUpSuite(c)
}
// In the case where we cannot examine an environment, we want the
// error to propagate back up to the user.
func (s *BootstrapSuite) TestBootstrapPropagatesEnvErrors(c *gc.C) {
//TODO(bogdanteleaga): fix this for windows once permissions are fixed
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: this is very platform specific. When/if we will support windows state machine, this will probably be rewritten.")
}
const envName = "devenv"
env := resetJujuHome(c, envName)
defaultSeriesVersion := version.Current
defaultSeriesVersion.Series = config.PreferredSeries(env.Config())
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
defaultSeriesVersion.Build = 1234
s.PatchValue(&version.Current, defaultSeriesVersion)
s.PatchValue(&environType, func(string) (string, error) { return "", nil })
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, jc.ErrorIsNil)
// Change permissions on the jenv file to simulate some kind of
// unexpected error when trying to read info from the environment
jenvFile := gitjujutesting.HomePath(".juju", "environments", envName+".jenv")
err = os.Chmod(jenvFile, os.FileMode(0200))
c.Assert(err, jc.ErrorIsNil)
// The second bootstrap should fail b/c of the propogated error
_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, gc.ErrorMatches, "there was an issue examining the environment: .*")
}
func (s *MongoSuite) TestInstallMongodFallsBack(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping TestInstallMongodFallsBack as mongo is not installed on windows")
}
type installs struct {
series string
cmd string
}
tests := []installs{
{"precise", "mongodb-server"},
{"trusty", "juju-mongodb3.2\njuju-mongodb"},
{"wily", "juju-mongodb3.2\njuju-mongodb"},
{"xenial", "juju-mongodb3.2\njuju-mongodb"},
}
dataDir := c.MkDir()
outputFile := filepath.Join(dataDir, "apt-get-args")
testing.PatchExecutable(c, s, "apt-get", fmt.Sprintf(fakeInstallScript, outputFile))
for _, test := range tests {
c.Logf("Testing mongo install for series: %s", test.series)
s.patchSeries(test.series)
err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
c.Assert(err, jc.ErrorIsNil)
args, err := ioutil.ReadFile(outputFile)
c.Assert(err, jc.ErrorIsNil)
c.Check(strings.TrimSpace(string(args)), gc.Equals, test.cmd)
err = os.Remove(outputFile)
c.Assert(err, jc.ErrorIsNil)
}
}
func (s *lxcBrokerSuite) SetUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping lxc tests on windows")
}
s.lxcSuite.SetUpTest(c)
var err error
s.agentConfig, err = agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: agent.NewPathsWithDefaults(agent.Paths{DataDir: "/not/used/here"}),
Tag: names.NewMachineTag("1"),
UpgradedToVersion: jujuversion.Current,
Password: "******",
Nonce: "nonce",
APIAddresses: []string{"10.0.0.1:1234"},
CACert: coretesting.CACert,
Model: coretesting.ModelTag,
})
c.Assert(err, jc.ErrorIsNil)
managerConfig := container.ManagerConfig{
container.ConfigName: "juju",
"log-dir": c.MkDir(),
"use-clone": "false",
}
s.api = NewFakeAPI()
s.broker, err = provisioner.NewLxcBroker(s.api, s.agentConfig, managerConfig, nil, false, 0)
c.Assert(err, jc.ErrorIsNil)
}
func (s *JujuCMainSuite) TestBadClientId(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: test panics on CryptAcquireContext on windows")
}
output := run(c, s.sockPath, "ben", 1, nil, "remote")
c.Assert(output, gc.Equals, "error: bad request: bad context: ben\n")
}
func (s *JujuCMainSuite) TestStdin(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: test panics on CryptAcquireContext on windows")
}
output := run(c, s.sockPath, "bill", 0, []byte("some standard input"), "remote")
c.Assert(output, gc.Equals, "some standard input")
}
func (s *LibVertSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
// Skip if not linux
if runtime.GOOS != "linux" {
c.Skip("not running linux")
}
}
func (s *ContainerSetupSuite) SetUpSuite(c *gc.C) {
// TODO(bogdanteleaga): Fix this on windows
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Skipping container tests on windows")
}
s.CommonProvisionerSuite.SetUpSuite(c)
}
func (s *syslogSuite) SetUpTest(c *gc.C) {
if runtime.GOOS != "linux" {
c.Skip(fmt.Sprintf("this test requires a controller, therefore does not support %q", runtime.GOOS))
}
currentSeries := series.HostSeries()
osFromSeries, err := series.GetOSFromSeries(currentSeries)
c.Assert(err, jc.ErrorIsNil)
if osFromSeries != os.Ubuntu {
c.Skip(fmt.Sprintf("this test requires a controller, therefore does not support OS %q only Ubuntu", osFromSeries.String()))
}
s.AgentSuite.SetUpTest(c)
// TODO(perrito666) 200160701:
// This needs to be done to stop the test from trying to install mongo
// while running, but it is a huge footprint for such little benefit.
// This test should not need JujuConnSuite or AgentSuite.
s.fakeEnsureMongo = agenttest.InstallFakeEnsureMongo(s)
done := make(chan struct{})
s.received = make(chan rfc5424test.Message)
addr := s.createSyslogServer(c, s.received, done)
// Leave log forwarding disabled initially, it will be enabled
// via a model config update in the test.
err = s.State.UpdateModelConfig(map[string]interface{}{
"syslog-host": addr,
"syslog-ca-cert": coretesting.CACert,
"syslog-client-cert": coretesting.ServerCert,
"syslog-client-key": coretesting.ServerKey,
}, nil, nil)
c.Assert(err, jc.ErrorIsNil)
s.logsCh, err = logsender.InstallBufferedLogWriter(1000)
c.Assert(err, jc.ErrorIsNil)
}
func (s *networkerSuite) TestPrimaryOrLoopbackInterfacesAreSkipped(c *gc.C) {
c.Skip("enable once the networker is enabled again")
// Reset what's considered up, so we can test eth0 and lo are not
// touched.
s.upInterfaces = make(set.Strings)
s.interfacesWithAddress = make(set.Strings)
nw, _ := s.newCustomNetworker(c, s.apiFacade, s.stateMachine.Id(), true, false)
defer worker.Stop(nw)
timeout := time.After(coretesting.LongWait)
for {
select {
case <-s.lastCommands:
if !s.vlanModuleLoaded {
// VLAN module loading commands is one of the first things
// the worker does, so if hasn't happened, we wait a bit more.
continue
}
c.Assert(s.upInterfaces.Contains("lo"), jc.IsFalse)
c.Assert(s.upInterfaces.Contains("eth0"), jc.IsFalse)
if s.upInterfaces.Contains("eth1") {
// If we run ifup eth1, we successfully skipped lo and
// eth0.
s.assertHaveConfig(c, nw, "", "eth0", "eth1", "eth1.42", "eth0.69")
return
}
case <-timeout:
c.Fatalf("commands expected but not executed")
}
}
}
func (s *credentialsSuite) TestDetectCredentialsNovarc(c *gc.C) {
if runtime.GOOS != "linux" {
c.Skip("not running linux")
}
home := utils.Home()
dir := c.MkDir()
utils.SetHome(dir)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
content := `
# Some secrets
export OS_TENANT_NAME=gary
EXPORT OS_USERNAME=bob
export OS_PASSWORD = dobbs
OS_REGION_NAME=region
`[1:]
novarc := filepath.Join(dir, ".novarc")
err := ioutil.WriteFile(novarc, []byte(content), 0600)
credentials, err := s.provider.DetectCredentials()
c.Assert(err, jc.ErrorIsNil)
c.Assert(credentials.DefaultRegion, gc.Equals, "region")
expected := cloud.NewCredential(
cloud.UserPassAuthType, map[string]string{
"username": "******",
"password": "******",
"tenant-name": "gary",
"domain-name": "",
},
)
expected.Label = `openstack region "region" project "gary" user "bob"`
c.Assert(credentials.AuthCredentials["bob"], jc.DeepEquals, expected)
}
func (s *MemReconSuite) TestOneSidedRidiculous(c *gc.C) {
if !*long {
c.Skip("long running test")
}
s.RunOneSided(c, 150000, true, 300*time.Second)
s.RunOneSided(c, 150000, false, 300*time.Second)
}
func (s *RebootSuite) SetUpTest(c *gc.C) {
if testing.GOVERSION < 1.3 {
c.Skip("skipping test, lxd requires Go 1.3 or later")
}
s.JujuConnSuite.SetUpTest(c)
testing.PatchExecutableAsEchoArgs(c, s, rebootBin)
s.PatchEnvironment("TEMP", c.MkDir())
s.tmpDir = c.MkDir()
s.rebootScriptName = "juju-reboot-script"
s.PatchValue(reboot.TmpFile, func() (*os.File, error) {
script := s.rebootScript(c)
return os.Create(script)
})
s.mgoInst.EnableAuth = true
err := s.mgoInst.Start(coretesting.Certs)
c.Assert(err, jc.ErrorIsNil)
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: c.MkDir()},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: jujuversion.Current,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: coretesting.CACert,
Password: "******",
Model: s.State.ModelTag(),
MongoVersion: mongo.Mongo24,
}
s.st, _ = s.OpenAPIAsNewMachine(c)
s.acfg, err = agent.NewAgentConfig(configParams)
c.Assert(err, jc.ErrorIsNil)
}
func (s *syncSuite) setUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
// It's important that this be v1.8.x to match the test data.
s.PatchValue(&jujuversion.Current, version.MustParse("1.8.3"))
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, jc.ErrorIsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "released", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "released", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (s *DebugHooksSuite) TestDebugHooksCommand(c *gc.C) {
//TODO(bogdanteleaga): Fix once debughooks are supported on windows
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Skipping on windows for now")
}
machines := s.makeMachines(3, c, true)
dummy := s.AddTestingCharm(c, "dummy")
srv := s.AddTestingService(c, "mysql", dummy)
s.addUnit(srv, machines[0], c)
srv = s.AddTestingService(c, "mongodb", dummy)
s.addUnit(srv, machines[1], c)
s.addUnit(srv, machines[2], c)
for i, t := range debugHooksTests {
c.Logf("test %d: %s\n\t%s\n", i, t.info, t.args)
ctx := coretesting.Context(c)
debugHooksCmd := &debugHooksCommand{}
debugHooksCmd.proxy = true
err := modelcmd.Wrap(debugHooksCmd).Init(t.args)
if err == nil {
err = modelcmd.Wrap(debugHooksCmd).Run(ctx)
}
if t.error != "" {
c.Assert(err, gc.ErrorMatches, t.error)
} else {
c.Assert(err, jc.ErrorIsNil)
}
}
}
func (s *JujuCMainSuite) TestNoClientId(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: test panics on CryptAcquireContext on windows")
}
output := run(c, s.sockPath, "", 1, nil, "remote")
c.Assert(output, gc.Equals, "error: JUJU_CONTEXT_ID not set\n")
}
func (s *createSuite) TestLegacy(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Currently does not work on windows, see comments inside backups.create function")
}
meta := backupstesting.NewMetadataStarted()
metadataFile, err := meta.AsJSONBuffer()
c.Assert(err, jc.ErrorIsNil)
_, testFiles, expected := s.createTestFiles(c)
dumper := &TestDBDumper{}
args := backups.NewTestCreateArgs(testFiles, dumper, metadataFile)
result, err := backups.Create(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.NotNil)
archiveFile, size, checksum := backups.ExposeCreateResult(result)
c.Assert(archiveFile, gc.NotNil)
// Check the result.
file, ok := archiveFile.(*os.File)
c.Assert(ok, jc.IsTrue)
s.checkSize(c, file, size)
s.checkChecksum(c, file, checksum)
s.checkArchive(c, file, expected)
}
func (s *JujuCMainSuite) TestNoSockPath(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: test panics on CryptAcquireContext on windows")
}
output := run(c, "", "bill", 1, nil, "remote")
c.Assert(output, gc.Equals, "error: JUJU_AGENT_SOCKET not set\n")
}
func (s *ProxyUpdaterSuite) waitForFile(c *gc.C, filename, expected string) {
//TODO(bogdanteleaga): Find a way to test this on windows
if runtime.GOOS == "windows" {
c.Skip("Proxy settings are written to the registry on windows")
}
maxWait := time.After(coretesting.LongWait)
for {
select {
case <-maxWait:
c.Fatalf("timeout while waiting for proxy settings to change")
return
case <-time.After(10 * time.Millisecond):
fileContent, err := ioutil.ReadFile(filename)
if os.IsNotExist(err) {
continue
}
c.Assert(err, jc.ErrorIsNil)
if string(fileContent) != expected {
c.Logf("file content not matching, still waiting")
continue
}
return
}
}
}
func (s *BootstrapSuite) TestGUIArchiveInfoError(c *gc.C) {
if runtime.GOOS == "windows" {
// TODO frankban: skipping for now due to chmod problems with mode 0000
// on Windows. We will re-enable this test after further investigation:
// "jujud bootstrap" is never run on Windows anyway.
c.Skip("needs chmod investigation")
}
dir := filepath.FromSlash(agenttools.SharedGUIDir(s.dataDir))
info := filepath.Join(dir, "downloaded-gui.txt")
err := os.Chmod(info, 0000)
c.Assert(err, jc.ErrorIsNil)
defer os.Chmod(info, 0600)
_, cmd, err := s.initBootstrapCommand(
c, nil, "--model-config", s.b64yamlControllerModelConfig,
"--hosted-model-config", s.b64yamlHostedModelConfig,
"--instance-id", string(s.instanceId))
c.Assert(err, jc.ErrorIsNil)
var tw loggo.TestWriter
err = loggo.RegisterWriter("bootstrap-test", &tw, loggo.DEBUG)
c.Assert(err, jc.ErrorIsNil)
defer loggo.RemoveWriter("bootstrap-test")
err = cmd.Run(nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(tw.Log(), jc.LogMatches, jc.SimpleMessages{{
loggo.WARNING,
`cannot set up Juju GUI: cannot fetch GUI info: cannot read GUI metadata in tools directory: .*`,
}})
}
func (s *workerSuite) TestMongoErrorNoCommonSpace(c *gc.C) {
c.Skip("dimitern: test disabled as it needs refactoring")
DoTestForIPv4AndIPv6(func(ipVersion TestIPVersion) {
st, machines, hostPorts := mongoSpaceTestCommonSetup(c, ipVersion, false)
for i, machine := range machines {
// machine 10 gets a host port in space one
// machine 11 gets a host port in space two
// machine 12 gets a host port in space three
st.machine(machine).setMongoHostPorts(hostPorts[i : i+1])
}
w := startWorkerSupportingSpaces(c, st, ipVersion)
done := make(chan error)
go func() {
done <- w.Wait()
}()
select {
case err := <-done:
c.Assert(err, gc.ErrorMatches, ".*couldn't find a space containing all peer group machines")
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for worker to exit")
}
// Each machine is in a unique space, so the Mongo space should be empty
c.Assert(st.getMongoSpaceName(), gc.Equals, "")
c.Assert(st.getMongoSpaceState(), gc.Equals, state.MongoSpaceInvalid)
})
}
func (s *lxcProvisionerSuite) SetUpSuite(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping lxc tests on windows")
}
s.CommonProvisionerSuite.SetUpSuite(c)
s.lxcSuite.SetUpSuite(c)
}
func (s *RunCommandSuite) TestRunCommandsEnvStdOutAndErrAndRC(c *gc.C) {
// TODO(bogdanteleaga): powershell throws another exit status code when
// outputting to stderr using Write-Error. Either find another way to
// output to stderr or change the checks
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Have to figure out a good way to output to stderr from powershell")
}
ctx, err := s.contextFactory.HookContext(hook.Info{Kind: hooks.ConfigChanged})
c.Assert(err, jc.ErrorIsNil)
paths := runnertesting.NewRealPaths(c)
runner := runner.NewRunner(ctx, paths)
commands := `
echo $JUJU_CHARM_DIR
echo this is standard err >&2
exit 42
`
result, err := runner.RunCommands(commands)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Code, gc.Equals, 42)
c.Assert(strings.TrimRight(string(result.Stdout), "\r\n"), gc.Equals, paths.GetCharmDir())
c.Assert(strings.TrimRight(string(result.Stderr), "\r\n"), gc.Equals, "this is standard err")
c.Assert(ctx.GetProcess(), gc.NotNil)
}
func (s *keyManagerSuite) TestDeleteKeysInvalidUser(c *gc.C) {
c.Skip("no user validation done yet")
s.assertInvalidUserOperation(c, func(args params.ModifyUserSSHKeys) error {
_, err := s.keymanager.DeleteKeys(args)
return err
})
}
func (s *kvmProvisionerSuite) SetUpSuite(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Skipping kvm tests on windows")
}
s.CommonProvisionerSuite.SetUpSuite(c)
s.kvmSuite.SetUpSuite(c)
}
func (s *tmpfsSuite) SetUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("Tests relevant only on *nix systems")
}
s.BaseSuite.SetUpTest(c)
s.storageDir = c.MkDir()
}
func (s *badBuildSuite) SetUpSuite(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
s.CleanupSuite.SetUpSuite(c)
s.LoggingSuite.SetUpSuite(c)
}
func (s *workerSuite) SetUpTest(c *gc.C) {
//TODO(bogdanteleaga): Fix this on windows
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: authentication worker not implemented yet on windows")
}
s.JujuConnSuite.SetUpTest(c)
// Default ssh user is currently "ubuntu".
c.Assert(authenticationworker.SSHUser, gc.Equals, "ubuntu")
// Set the ssh user to empty (the current user) as required by the test infrastructure.
s.PatchValue(&authenticationworker.SSHUser, "")
// Replace the default dummy key in the test environment with a valid one.
// This will be added to the ssh authorised keys when the agent starts.
s.setAuthorisedKeys(c, sshtesting.ValidKeyOne.Key+" firstuser@host")
// Record the existing key with its prefix for testing later.
s.existingEnvKey = sshtesting.ValidKeyOne.Key + " Juju:firstuser@host"
// Set up an existing key (which is not in the environment) in the ssh authorised_keys file.
s.existingKeys = []string{sshtesting.ValidKeyTwo.Key + " existinguser@host"}
err := ssh.AddKeys(authenticationworker.SSHUser, s.existingKeys...)
c.Assert(err, jc.ErrorIsNil)
var apiRoot api.Connection
apiRoot, s.machine = s.OpenAPIAsNewMachine(c)
c.Assert(apiRoot, gc.NotNil)
s.keyupdaterApi = apiRoot.KeyUpdater()
c.Assert(s.keyupdaterApi, gc.NotNil)
}
// testRequires checks if the environment satisfies the requirements
// for the test to run or skips the tests.
func testRequires(c *check.C, requirements ...testRequirement) {
for _, r := range requirements {
if !r.Condition() {
c.Skip(r.SkipMessage)
}
}
}