Golang testing.AssertEchoArgs函数代码示例

func (s *MongoSuite) TestInstallSuccessMongodCentOS(c *gc.C) {
	type installs struct {
		series string
		pkg    string
	}
	test := installs{
		"centos7", "mongodb*",
	}

	testing.PatchExecutableAsEchoArgs(c, s, "yum")
	testing.PatchExecutableAsEchoArgs(c, s, "chcon")
	testing.PatchExecutableAsEchoArgs(c, s, "semanage")

	dataDir := c.MkDir()
	s.patchSeries(test.series)

	err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
	c.Assert(err, jc.ErrorIsNil)

	expected := append(expectedArgs.YumBase, "epel-release")

	testing.AssertEchoArgs(c, "yum", expected...)

	testing.AssertEchoArgs(c, "chcon", expectedArgs.Chcon...)

	testing.AssertEchoArgs(c, "semanage", expectedArgs.Semanage...)
}

func (s *lxcBrokerSuite) TestSetupRoutesAndIPTablesAddsRuleIfMissing(c *gc.C) {
	// Isolate the test from the host machine. Because PatchExecutable
	// does not allow us to assert on subsequent executions of the
	// same binary, we need to replace the iptables commands with
	// separate ones. The check returns code=1 to trigger calling
	// add.
	fakeptablesRules := map[string]provisioner.IptablesRule{
		"IPTablesSNAT": {
			"nat",
			"POSTROUTING",
			"{{.HostIF}} {{.HostIP}}",
		},
	}
	s.PatchValue(provisioner.IptablesRules, fakeptablesRules)

	gitjujutesting.PatchExecutableAsEchoArgs(c, s, "iptables", 1, 0)
	gitjujutesting.PatchExecutableAsEchoArgs(c, s, "ip")

	ifaceInfo := []network.InterfaceInfo{{
		Address: network.NewAddress("0.1.2.3"),
	}}

	addr := network.NewAddress("0.1.2.1")
	err := provisioner.SetupRoutesAndIPTables("nic", addr, "bridge", ifaceInfo, false)
	c.Assert(err, jc.ErrorIsNil)

	// Now verify the expected commands - since check returns 1, add
	// will be called before ip route add.

	gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-C", "POSTROUTING", "nic", "0.1.2.1")
	gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-I", "POSTROUTING", "1", "nic", "0.1.2.1")
	gitjujutesting.AssertEchoArgs(c, "ip", "route", "add", "0.1.2.3", "dev", "bridge")
}

func (s *MongoSuite) TestAddPPAInQuantal(c *gc.C) {
	testing.PatchExecutableAsEchoArgs(c, s, "apt-get")

	testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
	s.patchSeries("quantal")

	dataDir := c.MkDir()
	err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
	c.Assert(err, jc.ErrorIsNil)

	pack := [][]string{
		{
			"install",
			"python-software-properties",
		}, {
			"install",
			"--target-release",
			"mongodb-server",
		},
	}
	noCommand := len(expectedArgs.AptGetBase) - 1
	for k := range pack {
		cmd := append(expectedArgs.AptGetBase[:noCommand], pack[k]...)
		testing.AssertEchoArgs(c, "apt-get", cmd...)
	}

	match := []string{
		"--yes",
		"\"ppa:juju/stable\"",
	}

	testing.AssertEchoArgs(c, "add-apt-repository", match...)
}

// Test that the call to SyncImages utilizes the defined source
func (s *LibVertSuite) TestSyncImagesUtilizesSimpleStreamsSource(c *gc.C) {

	const simpStreamsBinName = "uvt-simplestreams-libvirt"
	testing.PatchExecutableAsEchoArgs(c, s, simpStreamsBinName)

	const (
		series = "mocked-series"
		arch   = "mocked-arch"
		source = "mocked-url"
	)
	err := kvm.SyncImages(series, arch, source)
	c.Assert(err, jc.ErrorIsNil)

	expectedArgs := strings.Split(
		fmt.Sprintf(
			"sync arch=%s release=%s --source=%s",
			arch,
			series,
			source,
		),
		" ",
	)

	testing.AssertEchoArgs(c, simpStreamsBinName, expectedArgs...)
}

func (s *cmdSuite) TestPatchExecutableNoArgs(c *gc.C) {
	s.EnsureArgFileRemoved(testFunc)
	testing.PatchExecutableAsEchoArgs(c, s, testFunc)
	output := runCommand(c, testFunc)
	c.Assert(output, gc.Equals, testFunc+"\n")
	testing.AssertEchoArgs(c, testFunc)
}

func (s *KVMSuite) TestStartContainerUtilizesSimpleStream(c *gc.C) {

	const libvirtBinName = "uvt-simplestreams-libvirt"
	testing.PatchExecutableAsEchoArgs(c, s, libvirtBinName)

	startParams := kvm.StartParams{
		Series:           "mocked-series",
		Arch:             "mocked-arch",
		ImageDownloadUrl: "mocked-url",
	}
	mockedContainer := kvm.NewEmptyKvmContainer()
	mockedContainer.Start(startParams)

	expectedArgs := strings.Split(
		fmt.Sprintf(
			"sync arch=%s release=%s --source=%s",
			startParams.Arch,
			startParams.Series,
			startParams.ImageDownloadUrl,
		),
		" ",
	)

	testing.AssertEchoArgs(c, libvirtBinName, expectedArgs...)
}

func (s *KVMSuite) TestCreateMachineUsesTemplate(c *gc.C) {
	const uvtKvmBinName = "uvt-kvm"
	testing.PatchExecutableAsEchoArgs(c, s, uvtKvmBinName)

	tempDir := c.MkDir()
	params := kvm.CreateMachineParams{
		Hostname:      "foo-bar",
		NetworkBridge: "br0",
		Interfaces: []network.InterfaceInfo{
			{MACAddress: "00:16:3e:20:b0:11"},
		},
		UserDataFile: filepath.Join(tempDir, "something"),
	}

	err := kvm.CreateMachine(params)
	c.Assert(err, jc.ErrorIsNil)

	expectedArgs := []string{
		"create",
		"--log-console-output",
		"--user-data",
		filepath.Join(tempDir, "something"),
		"--template",
		filepath.Join(tempDir, "kvm-template.xml"),
		"foo-bar",
	}

	testing.AssertEchoArgs(c, uvtKvmBinName, expectedArgs...)
}

func (s *MongoSuite) TestInstallMongod(c *gc.C) {
	type installs struct {
		series string
		cmd    [][]string
	}

	tests := []installs{
		{"precise", [][]string{{"--target-release", "precise-updates/cloud-tools", "mongodb-server"}}},
		{"quantal", [][]string{{"python-software-properties"}, {"--target-release", "mongodb-server"}}},
		{"raring", [][]string{{"--target-release", "mongodb-server"}}},
		{"saucy", [][]string{{"--target-release", "mongodb-server"}}},
		{"trusty", [][]string{{"juju-mongodb"}}},
		{"u-series", [][]string{{"juju-mongodb"}}},
	}

	testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
	testing.PatchExecutableAsEchoArgs(c, s, "apt-get")
	for _, test := range tests {
		dataDir := c.MkDir()
		namespace := "namespace" + test.series
		s.patchSeries(test.series)
		err := mongo.EnsureServer(makeEnsureServerParams(dataDir, namespace))
		c.Assert(err, jc.ErrorIsNil)

		for _, cmd := range test.cmd {
			match := append(expectedArgs.AptGetBase, cmd...)
			testing.AssertEchoArgs(c, "apt-get", match...)
		}
	}
}

func (s *MongoSuite) TestInstallMongod(c *gc.C) {
	type installs struct {
		series string
		cmd    [][]string
	}

	tests := []installs{
		{"precise", [][]string{{"--target-release", "precise-updates/cloud-tools", "mongodb-server"}}},
		{"trusty", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
		{"wily", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
		{"xenial", [][]string{{"juju-mongodb3.2"}, {"juju-mongo-tools3.2"}}},
	}

	testing.PatchExecutableAsEchoArgs(c, s, "add-apt-repository")
	testing.PatchExecutableAsEchoArgs(c, s, "apt-get")
	for _, test := range tests {
		c.Logf("install for series %v", test.series)
		dataDir := c.MkDir()
		s.patchSeries(test.series)
		err := mongo.EnsureServer(makeEnsureServerParams(dataDir))
		c.Assert(err, jc.ErrorIsNil)

		for _, cmd := range test.cmd {
			match := append(expectedArgs.AptGetBase, cmd...)
			testing.AssertEchoArgs(c, "apt-get", match...)
		}
	}
}

func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
	s.EnsureArgFileRemoved(testFunc)
	testing.PatchExecutableAsEchoArgs(c, s, testFunc)
	output := runCommand(c, testFunc, "foo", "bar baz")
	c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\n")
	testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}

func (s *RebootSuite) TestShutdownNoContainers(c *gc.C) {
	w, err := reboot.NewRebootWaiter(s.st, s.acfg)
	c.Assert(err, jc.ErrorIsNil)
	expectedShutdownParams := s.shutdownCommandParams(c)

	err = w.ExecuteReboot(params.ShouldShutdown)
	c.Assert(err, jc.ErrorIsNil)
	testing.AssertEchoArgs(c, rebootBin, expectedShutdownParams...)
}

func (s *RebootSuite) TestRebootNoContainers(c *gc.C) {
	w, err := reboot.NewRebootWaiter(s.st, s.acfg)
	c.Assert(err, jc.ErrorIsNil)
	expectedRebootParams := s.rebootCommandParams(c)

	err = w.ExecuteReboot(params.ShouldReboot)
	c.Assert(err, jc.ErrorIsNil)
	testing.AssertEchoArgs(c, rebootBin, expectedRebootParams...)
	ft.File{s.rebootScriptName, expectedRebootScript, 0755}.Check(c, s.tmpDir)
}

func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
	s.EnsureArgFileRemoved(testFunc)
	testing.PatchExecutableAsEchoArgs(c, s, testFunc)
	output := runCommand(c, testFunc, "foo", "bar baz")
	output = strings.TrimRight(output, "\r\n")

	c.Assert(output, gc.DeepEquals, testFunc+" 'foo' 'bar baz'")

	testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}

func (s *cmdSuite) TestPatchExecutableWithArgs(c *gc.C) {
	s.EnsureArgFileRemoved(testFunc)
	testing.PatchExecutableAsEchoArgs(c, s, testFunc)
	output := runCommand(c, testFunc, "foo", "bar baz")
	switch runtime.GOOS {
	case "windows":
		c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\r\n")
	default:
		c.Assert(output, gc.Equals, testFunc+" \"foo\" \"bar baz\"\n")
	}
	testing.AssertEchoArgs(c, testFunc, "foo", "bar baz")
}

func (s *MongoSuite) TestAddEpelInCentOS(c *gc.C) {
	testing.PatchExecutableAsEchoArgs(c, s, "yum")

	s.patchSeries("centos7")

	testing.PatchExecutableAsEchoArgs(c, s, "chcon")
	testing.PatchExecutableAsEchoArgs(c, s, "semanage")

	dataDir := c.MkDir()
	err := mongo.EnsureServer(makeEnsureServerParams(dataDir, ""))
	c.Assert(err, jc.ErrorIsNil)

	expectedEpelRelease := append(expectedArgs.YumBase, "epel-release")
	testing.AssertEchoArgs(c, "yum", expectedEpelRelease...)

	expectedMongodbServer := append(expectedArgs.YumBase, "mongodb-server")
	testing.AssertEchoArgs(c, "yum", expectedMongodbServer...)

	testing.AssertEchoArgs(c, "chcon", expectedArgs.Chcon...)

	testing.AssertEchoArgs(c, "semanage", expectedArgs.Semanage...)
}