func (s *JujuCMainSuite) TestArgs(c *gc.C) {
for _, t := range argsTests {
c.Log(t.args)
output := run(c, s.sockPath, "bill", t.code, t.args...)
c.Assert(output, gc.Equals, t.output)
}
}
func (s *IntegrationTestSuite) TestSimpleInstallAndStartImage(c *chk.C) {
id, err := containers.NewIdentifier("IntTest000")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId)
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerState(c, id, CONTAINER_STOPPED)
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
paths, err := filepath.Glob(id.VersionedUnitPathFor("*"))
c.Assert(err, chk.IsNil)
for _, p := range paths {
s.assertFilePresent(c, p, 0664, true)
}
s.assertFileAbsent(c, filepath.Join(id.HomePath(), "container-init.sh"))
ports, err := containers.GetExistingPorts(id)
c.Assert(err, chk.IsNil)
c.Assert(len(ports), chk.Equals, 0)
cmd = exec.Command("/usr/bin/gear", "status", hostContainerId)
data, err = cmd.CombinedOutput()
c.Assert(err, chk.IsNil)
c.Log(string(data))
c.Assert(strings.Contains(string(data), "Loaded: loaded (/var/lib/containers/units/In/ctr-IntTest000.service; enabled)"), chk.Equals, true)
s.assertContainerState(c, id, CONTAINER_STOPPED)
}
func (s *S) TestWeightedTimeSeeded(c *check.C) {
c.Log("Note: This test is stochastic and is expected to fail with probability ≈ 0.05.")
rand.Seed(time.Now().Unix())
f := make([]float64, len(sel))
ts := make(Selector, len(sel))
for i := 0; i < 1e6; i++ {
copy(ts, sel)
ts.Init()
item, err := ts.Select()
if err != nil {
c.Fatal(err)
}
f[item-1]++
}
fsum, exsum := 0., 0.
for i := range f {
fsum += f[i]
exsum += exp[i]
}
fac := fsum / exsum
for i := range f {
exp[i] *= fac
}
// Check that our obtained values are within statistical expectations for p = 0.05.
// This will not be true approximately 1 in 20 tests.
X := chi2(f, exp)
c.Logf("H₀: d(Sample) = d(Expect), H₁: d(S) ≠ d(Expect). df = %d, p = 0.05, X² threshold = %.2f, X² = %f", len(f)-1, sigChi2, X)
c.Check(X < sigChi2, check.Equals, true)
}
func (s *ActionSuite) TestMergeIds(c *gc.C) {
var tests = []struct {
initial string
changes string
adds string
removes string
expected string
}{
{initial: "", changes: "", adds: "a0,a1", removes: "", expected: "a0,a1"},
{initial: "", changes: "a0,a1", adds: "", removes: "a0", expected: "a1"},
{initial: "", changes: "a0,a1", adds: "a2", removes: "a0", expected: "a1,a2"},
{initial: "a0", changes: "", adds: "a0,a1,a2", removes: "a0,a2", expected: "a1"},
{initial: "a0", changes: "", adds: "a0,a1,a2", removes: "a0,a1,a2", expected: ""},
{initial: "a0", changes: "a0", adds: "a0,a1,a2", removes: "a0,a2", expected: "a1"},
{initial: "a0", changes: "a1", adds: "a0,a1,a2", removes: "a0,a2", expected: "a1"},
{initial: "a0", changes: "a2", adds: "a0,a1,a2", removes: "a0,a2", expected: "a1"},
{initial: "a0,a1,a2", changes: "a3,a4", adds: "a1,a4,a5", removes: "a1,a3", expected: "a4,a5"},
{initial: "a0,a1,a2", changes: "a0,a1,a2", adds: "a1,a4,a5", removes: "a1,a3", expected: "a0,a2,a4,a5"},
}
for ix, test := range tests {
updates := mapify(test.adds, test.removes)
changes := newSet(test.changes)
initial := newSet(test.initial)
expected := newSet(test.expected)
c.Log(fmt.Sprintf("test number %d %+v", ix, test))
err := state.WatcherMergeIds(changes, initial, updates)
c.Assert(err, gc.IsNil)
c.Assert(changes.SortedValues(), jc.DeepEquals, expected.SortedValues())
}
}
func (b *buildSuite) SetUpTest(c *gc.C) {
b.BaseSuite.SetUpTest(c)
dir1 := c.MkDir()
dir2 := c.MkDir()
c.Log(dir1)
c.Log(dir2)
path := os.Getenv("PATH")
os.Setenv("PATH", fmt.Sprintf("%s:%s:%s", dir1, dir2, path))
// Make an executable file called "juju-test" in dir2.
b.filePath = filepath.Join(dir2, "juju-test")
err := ioutil.WriteFile(
b.filePath,
[]byte("doesn't matter, we don't execute it"),
0755)
c.Assert(err, gc.IsNil)
cwd, err := os.Getwd()
c.Assert(err, gc.IsNil)
b.cwd = c.MkDir()
err = os.Chdir(b.cwd)
c.Assert(err, gc.IsNil)
b.restore = func() {
os.Setenv("PATH", path)
os.Chdir(cwd)
}
}
func (s *IntegrationTestSuite) TestRestartContainer(c *chk.C) {
id, err := containers.NewIdentifier("IntTest004")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:4002", "--start", "--isolate")
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
s.assertContainerState(c, id, CONTAINER_STARTED)
s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false)
oldPid := s.getContainerPid(id)
cmd = exec.Command("/usr/bin/gear", "restart", hostContainerId)
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerState(c, id, CONTAINER_RESTARTED)
newPid := s.getContainerPid(id)
c.Assert(oldPid, chk.Not(chk.Equals), newPid)
}
func (s *syncSuite) TestSyncing(c *gc.C) {
for _, test := range tests {
// Perform all tests in a "clean" environment.
func() {
s.setUpTest(c)
defer s.tearDownTest(c)
c.Log(test.description)
if test.source {
test.ctx.Source = s.localStorage
}
err := sync.SyncTools(test.ctx)
c.Assert(err, gc.IsNil)
targetTools, err := environs.FindAvailableTools(s.targetEnv, 1)
c.Assert(err, gc.IsNil)
assertToolsList(c, targetTools, test.tools)
if test.emptyPublic {
assertEmpty(c, s.targetEnv.PublicStorage())
} else {
assertEmpty(c, s.targetEnv.Storage())
}
}()
}
}
func (*InstanceTypeSuite) TestIsValidArch(c *gc.C) {
types := preferredTypes{}
// No architecture needs to be specified.
c.Check(types.isValidArch(nil), gc.Equals, true)
// Azure supports these architectures...
supported := []string{
"amd64",
"i386",
}
for _, arch := range supported {
c.Log("Checking that %q is supported.", arch)
c.Check(types.isValidArch(&arch), gc.Equals, true)
}
// ...But not these.
unsupported := []string{
"",
"axp",
"powerpc",
}
for _, arch := range unsupported {
c.Log("Checking that %q is not supported.", arch)
c.Check(types.isValidArch(&arch), gc.Equals, false)
}
}
func (*ArgsSuite) TestString(c *gc.C) {
for i, test := range []struct {
message string
target []string
expected string
}{{
message: "null",
expected: "",
}, {
message: "empty",
target: []string{},
expected: "",
}, {
message: "single value",
target: []string{"foo"},
expected: "foo",
}, {
message: "multiple values",
target: []string{"foo", "bar", "baz"},
expected: "foo,bar,baz",
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
var temp []string
value := cmd.NewStringsValue(test.target, &temp)
c.Assert(value.String(), gc.Equals, test.expected)
}
}
func (s *IntegrationTestSuite) TestLongContainerName(c *chk.C) {
id, err := containers.NewIdentifier("IntTest006xxxxxxxxxxxxxx")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--start", "--ports=8080:0", "--isolate")
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerStarts(c, id)
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
s.assertFilePresent(c, filepath.Join(id.RunPathFor(), "container-init.sh"), 0700, false)
ports, err := containers.GetExistingPorts(id)
c.Assert(err, chk.IsNil)
c.Assert(len(ports), chk.Equals, 1)
httpAlive := func() bool {
resp, err := http.Get(fmt.Sprintf("http://0.0.0.0:%v", ports[0].External))
if err == nil {
c.Assert(resp.StatusCode, chk.Equals, 200)
return true
}
return false
}
if !until(TimeoutContainerStateChange, IntervalHttpCheck, httpAlive) {
c.Errorf("Unable to retrieve a 200 status code from port %d", ports[0].External)
c.FailNow()
}
}
func (s *BootstrapS) TestLogAndGetTestLog(c *gocheck.C) {
c.Log("Hello there!")
log := c.GetTestLog()
if log != "Hello there!\n" {
critical(fmt.Sprintf("Log() or GetTestLog() is not working! Got: %#v", log))
}
}
func (s *IntegrationTestSuite) TestSamePortRejected(c *chk.C) {
id, err := containers.NewIdentifier("TestSamePortRejected")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:39485")
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
active, _ := s.unitState(id)
c.Assert(active, chk.Equals, "inactive")
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
paths, err := filepath.Glob(id.VersionedUnitPathFor("*"))
c.Assert(err, chk.IsNil)
for _, p := range paths {
s.assertFilePresent(c, p, 0664, true)
}
id2, _ := containers.NewIdentifier("TestSamePortRejected2")
cmd = exec.Command("/usr/bin/gear", "install", TestImage, fmt.Sprintf("%v/%v", s.daemonURI, id2), "--ports=8080:39485")
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.ErrorMatches, "exit status 1")
state, substate := s.unitState(id2)
c.Assert(state, chk.Equals, "inactive")
c.Assert(substate, chk.Equals, "dead")
}
func (*ArgsSuite) TestFlagsUsage(c *gc.C) {
for i, test := range []struct {
message string
defaultValue []string
args []string
expectedValue []string
}{{
message: "nil default and no arg",
}, {
message: "default value and not set by args",
defaultValue: []string{"foo", "bar"},
expectedValue: []string{"foo", "bar"},
}, {
message: "no value set by args",
args: []string{"--value", "foo,bar"},
expectedValue: []string{"foo", "bar"},
}, {
message: "default value and set by args",
defaultValue: []string{"omg"},
args: []string{"--value", "foo,bar"},
expectedValue: []string{"foo", "bar"},
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
f := gnuflag.NewFlagSet("test", gnuflag.ContinueOnError)
f.SetOutput(ioutil.Discard)
var value []string
f.Var(cmd.NewStringsValue(test.defaultValue, &value), "value", "help")
err := f.Parse(false, test.args)
c.Check(err, gc.IsNil)
c.Check(value, gc.DeepEquals, test.expectedValue)
}
}
func (*RunSuite) TestTimeoutArgParsing(c *gc.C) {
for i, test := range []struct {
message string
args []string
errMatch string
timeout time.Duration
}{{
message: "default time",
args: []string{"--all", "sudo reboot"},
timeout: 5 * time.Minute,
}, {
message: "invalid time",
args: []string{"--timeout=foo", "--all", "sudo reboot"},
errMatch: `invalid value "foo" for flag --timeout: time: invalid duration foo`,
}, {
message: "two hours",
args: []string{"--timeout=2h", "--all", "sudo reboot"},
timeout: 2 * time.Hour,
}, {
message: "3 minutes 30 seconds",
args: []string{"--timeout=3m30s", "--all", "sudo reboot"},
timeout: (3 * time.Minute) + (30 * time.Second),
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
runCmd := &RunCommand{}
testing.TestInit(c, envcmd.Wrap(runCmd), test.args, test.errMatch)
if test.errMatch == "" {
c.Check(runCmd.timeout, gc.Equals, test.timeout)
}
}
}
func (s *IntegrationTestSuite) TestLongContainerName(c *chk.C) {
id, err := containers.NewIdentifier("IntTest006xxxxxxxxxxxxxx")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--start", "--ports=8080:4003", "--isolate")
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerState(c, id, CONTAINER_STARTED)
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false)
ports, err := containers.GetExistingPorts(id)
c.Assert(err, chk.IsNil)
c.Assert(len(ports), chk.Equals, 1)
t := time.NewTicker(time.Second / 10)
defer t.Stop()
select {
case <-t.C:
resp, err := http.Get(fmt.Sprintf("http://0.0.0.0:%v", ports[0].External))
if err == nil {
c.Assert(resp.StatusCode, chk.Equals, 200)
}
case <-time.After(time.Second * 15):
c.Fail()
}
}
func (s *StoreSuite) SetUpSuite(c *gc.C) {
s.LoggingSuite.SetUpSuite(c)
s.MgoSuite.SetUpSuite(c)
s.HTTPSuite.SetUpSuite(c)
if os.Getenv("JUJU_NOTEST_MONGOJS") == "1" {
c.Log("Tests requiring MongoDB Javascript will be skipped")
*noTestMongoJs = true
}
}
func (s *StoreSuite) SetUpSuite(c *gc.C) {
s.FakeHomeSuite.SetUpSuite(c)
s.MgoSuite.SetUpSuite(c)
s.HTTPSuite.SetUpSuite(c)
if os.Getenv("JUJU_NOTEST_MONGOJS") == "1" || gitjujutesting.MgoServer.WithoutV8 {
c.Log("Tests requiring MongoDB Javascript will be skipped")
*noTestMongoJs = true
}
}
func (s *FileSuite) TestIsSymlink(c *gc.C) {
file, err := ioutil.TempFile(c.MkDir(), "")
c.Assert(err, gc.IsNil)
c.Log(file.Name())
c.Log(filepath.Dir(file.Name()))
symlinkPath := filepath.Join(filepath.Dir(file.Name()), "a-symlink")
err = os.Symlink(file.Name(), symlinkPath)
c.Assert(err, gc.IsNil)
c.Assert(symlinkPath, jc.IsSymlink)
}
func (fix *SimpleToolsFixture) checkUnitRemoved(c *gc.C, name string) {
tag := names.NewUnitTag(name).String()
confPath, agentDir, toolsDir := fix.paths(tag)
for _, path := range []string{confPath, agentDir, toolsDir} {
_, err := ioutil.ReadFile(path)
if err == nil {
c.Log("Warning: %q not removed as expected", path)
} else {
c.Assert(err, jc.Satisfies, os.IsNotExist)
}
}
}
func (s *RunSuite) TestSingleResponse(c *gc.C) {
mock := s.setupMockAPI()
mock.setMachinesAlive("0")
mockResponse := mockResponse{
stdout: "stdout\n",
stderr: "stderr\n",
code: 42,
machineId: "0",
}
mock.setResponse("0", mockResponse)
unformatted := ConvertRunResults([]params.RunResult{
makeRunResult(mockResponse)})
yamlFormatted, err := cmd.FormatYaml(unformatted)
c.Assert(err, gc.IsNil)
jsonFormatted, err := cmd.FormatJson(unformatted)
c.Assert(err, gc.IsNil)
for i, test := range []struct {
message string
format string
stdout string
stderr string
errorMatch string
}{{
message: "smart (default)",
stdout: "stdout\n",
stderr: "stderr\n",
errorMatch: "subprocess encountered error code 42",
}, {
message: "yaml output",
format: "yaml",
stdout: string(yamlFormatted) + "\n",
}, {
message: "json output",
format: "json",
stdout: string(jsonFormatted) + "\n",
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
args := []string{}
if test.format != "" {
args = append(args, "--format", test.format)
}
args = append(args, "--all", "ignored")
context, err := testing.RunCommand(c, envcmd.Wrap(&RunCommand{}), args...)
if test.errorMatch != "" {
c.Check(err, gc.ErrorMatches, test.errorMatch)
} else {
c.Check(err, gc.IsNil)
}
c.Check(testing.Stdout(context), gc.Equals, test.stdout)
c.Check(testing.Stderr(context), gc.Equals, test.stderr)
}
}
func (s *IntegrationTestSuite) TearDownSuite(c *chk.C) {
for _, id := range s.containerIds {
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "delete", hostContainerId)
data, err := cmd.CombinedOutput()
c.Log(string(data))
if err != nil {
c.Logf("Container %v did not cleanup properly", id)
}
}
}
func (s *UnitSuite) TestRemoveUnitMachineFastForwardDestroy(c *gc.C) {
for _, tc := range s.destroyMachineTestCases(c) {
c.Log(tc.desc)
c.Assert(tc.target.Destroy(), gc.IsNil)
if tc.destroyed {
assertLife(c, tc.host, state.Dying)
c.Assert(tc.host.EnsureDead(), gc.IsNil)
} else {
assertLife(c, tc.host, state.Alive)
c.Assert(tc.host.Destroy(), gc.NotNil)
}
}
}
func (s *IntegrationTestSuite) TestInstallEnv(c *chk.C) {
id, err := containers.NewIdentifier("TestInstallEnv")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
hostEnvId := fmt.Sprintf("%v/%v", s.daemonURI, "foobar")
cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-id=foobar", "A=B", "C=D", "--start")
data, err := cmd.CombinedOutput()
c.Log(cmd.Args)
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerStarts(c, id)
cmd = exec.Command("/usr/bin/gear", "status", hostContainerId)
data, err = cmd.CombinedOutput()
c.Assert(err, chk.IsNil)
c.Log(string(data))
c.Assert(strings.Contains(string(data), "A=B"), chk.Equals, true)
c.Assert(strings.Contains(string(data), "C=D"), chk.Equals, true)
cmd = exec.Command("/usr/bin/gear", "env", hostEnvId)
data, err = cmd.CombinedOutput()
c.Assert(err, chk.IsNil)
c.Log(string(data))
c.Assert(string(data), chk.Equals, "A=B\nC=D\n")
}
func (s *IntegrationTestSuite) TestSimpleInstallWithEnv(c *chk.C) {
if !*hasEnvFile {
c.Skip("-env-file not specified")
}
id, err := containers.NewIdentifier("IntTest008")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-file=deployment/fixtures/simple.env", "--start")
data, err := cmd.CombinedOutput()
c.Log(cmd.Args)
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerStarts(c, id)
cmd = exec.Command("/usr/bin/gear", "status", hostContainerId)
data, err = cmd.CombinedOutput()
c.Assert(err, chk.IsNil)
c.Log(string(data))
c.Assert(strings.Contains(string(data), "TEST=\"value\""), chk.Equals, true)
c.Assert(strings.Contains(string(data), "QUOTED=\"\\\"foo\\\"\""), chk.Equals, true)
c.Assert(strings.Contains(string(data), "IGNORED"), chk.Equals, false)
cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId)
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerStops(c, id, true)
}
// Assert thar contents checks that the tar reader provided contains the
// Expected files
// expectedContents: is a slice of the filenames with relative paths that are
// expected to be on the tar file
// tarFile: is the path of the file to be checked
func (t *TarSuite) assertTarContents(c *gc.C, expectedContents []expectedTarContents,
tarFile io.Reader) {
tr := tar.NewReader(tarFile)
tarContents := make(map[string]string)
// Iterate through the files in the archive.
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
c.Assert(err, gc.IsNil)
buf, err := ioutil.ReadAll(tr)
c.Assert(err, gc.IsNil)
tarContents[hdr.Name] = string(buf)
}
for _, expectedContent := range expectedContents {
fullExpectedContent := strings.TrimPrefix(expectedContent.Name, string(os.PathSeparator))
body, ok := tarContents[fullExpectedContent]
c.Log(tarContents)
c.Log(expectedContents)
c.Log(fmt.Sprintf("checking for presence of %q on tar file", fullExpectedContent))
c.Assert(ok, gc.Equals, true)
if expectedContent.Body != "" {
c.Log("Also checking the file contents")
c.Assert(body, gc.Equals, expectedContent.Body)
}
}
}
func (s *FoundationS) TestSucceedNow(c *gocheck.C) {
defer (func() {
if c.Failed() {
c.Error("SucceedNow() didn't succeed the test")
}
if c.GetTestLog() != "" {
c.Error("Something got logged:\n" + c.GetTestLog())
}
})()
c.Fail()
c.SucceedNow()
c.Log("SucceedNow() didn't stop the test")
}
func (s *IntegrationTestSuite) TestContainerNetLinks(c *chk.C) {
id, err := containers.NewIdentifier("IntTest007")
c.Assert(err, chk.IsNil)
s.containerIds = append(s.containerIds, id)
hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id)
cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:4004", "--isolate")
data, err := cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertFilePresent(c, id.UnitPathFor(), 0664, true)
cmd = exec.Command("/usr/bin/gear", "link", "-n", "127.0.0.1:8081:74.125.239.114:80", hostContainerId)
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
cmd = exec.Command("/usr/bin/gear", "start", hostContainerId)
data, err = cmd.CombinedOutput()
s.assertContainerState(c, id, CONTAINER_STARTED)
s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false)
cmd = exec.Command("/usr/bin/switchns", "--container="+id.ContainerFor(), "--", "/sbin/iptables", "-t", "nat", "-L")
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(strings.Contains(string(data), "tcp dpt:tproxy to:74.125.239.114"), chk.Equals, true)
cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId)
data, err = cmd.CombinedOutput()
c.Log(string(data))
c.Assert(err, chk.IsNil)
s.assertContainerState(c, id, CONTAINER_STOPPED)
}
func (s *MarshalSuite) TestDeltaMarshalJSON(c *gc.C) {
for _, t := range marshalTestCases {
c.Log(t.about)
output, err := t.value.MarshalJSON()
c.Check(err, gc.IsNil)
// We check unmarshalled output both to reduce the fragility of the
// tests (because ordering in the maps can change) and to verify that
// the output is well-formed.
var unmarshalledOutput interface{}
err = json.Unmarshal(output, &unmarshalledOutput)
c.Check(err, gc.IsNil)
var expected interface{}
err = json.Unmarshal([]byte(t.json), &expected)
c.Check(err, gc.IsNil)
c.Check(unmarshalledOutput, gc.DeepEquals, expected)
}
}
func (*ArgsSuite) TestSet(c *gc.C) {
for i, test := range []struct {
message string
arg string
expected []string
}{{
message: "empty",
expected: []string{""},
}, {
message: "just whitespace",
arg: " ",
expected: []string{" "},
}, {
message: "whitespace and comma",
arg: " , ",
expected: []string{" ", " "},
}, {
message: "single value",
arg: "foo",
expected: []string{"foo"},
}, {
message: "single value with comma",
arg: "foo,",
expected: []string{"foo", ""},
}, {
message: "single value with whitespace",
arg: " foo ",
expected: []string{" foo "},
}, {
message: "multiple values",
arg: "foo,bar,baz",
expected: []string{"foo", "bar", "baz"},
}, {
message: "multiple values with spaces",
arg: "foo, bar, baz",
expected: []string{"foo", " bar", " baz"},
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
var result []string
value := cmd.NewStringsValue(nil, &result)
error := value.Set(test.arg)
c.Check(error, gc.IsNil)
c.Check(result, gc.DeepEquals, test.expected)
}
}
func setUpAuth(c *gocheck.C) {
if !*amazon {
c.Skip("Test against amazon not enabled.")
}
if *local {
c.Log("Using local server")
dynamodb_region = aws.Region{DynamoDBEndpoint: "http://127.0.0.1:8000"}
dynamodb_auth = aws.Auth{AccessKey: "DUMMY_KEY", SecretKey: "DUMMY_SECRET"}
} else {
c.Log("Using REAL AMAZON SERVER")
dynamodb_region = aws.USEast
auth, err := aws.EnvAuth()
if err != nil {
c.Fatal(err)
}
dynamodb_auth = auth
}
}