Esempi in Golang per Main

Esempio n. 1

File: permission_problems_test.go Progetto: involucro/involucro

func TestCanWrapFilesOnlyReadableForRoot(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	if err := os.MkdirAll("test", 0755); err != nil {
		t.Fatal(err)
	}

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		app.Main([]string{
			"involucro", "-e", "inv.task('x').using('busybox').run('/bin/sh', '-c', 'rm -f /source/test/only_root')", "x",
		})
		c.RemoveImage("inttest/wrap_root")
	}()

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('x').using('busybox').run('/bin/sh', '-c', 'echo FLAG > /source/test/only_root && chmod 0400 /source/test/only_root')",
		"x",
	}); err != nil {
		t.Fatal(err)
	}

	file, err := os.Open("test/only_root")
	if err == nil {
		file.Close()
		t.Fatal("File opening succeeded")
	}

	if !os.IsPermission(err) {
		t.Fatal("Error was not a permission error, but", err)
	}

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('w').wrap('test').inImage('busybox').at('/data').as('inttest/wrap_root')",
		"w",
	}); err != nil {
		t.Fatal(err)
	}

	assertStdoutContainsFlag([]string{
		"-e",
		"inv.task('x').using('inttest/wrap_root').run('cat', '/data/only_root')",
		"x",
	}, "FLAG", t)
}

Esempio n. 2

File: wrap_without_workdir_test.go Progetto: involucro/involucro

func TestWrapCurrentDir(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	dir, err := ioutil.TempDir("", "inttest-58")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	if err := ioutil.WriteFile(filepath.Join(dir, "a"), []byte("123"), 0755); err != nil {
		t.Fatal(err)
	}

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	cwd, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		c.RemoveImage("inttest/58")
		os.Chdir(cwd)
	}()

	if err := os.Chdir(dir); err != nil {
		t.Fatal(err)
	}

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('wrap').wrap('.').inImage('busybox').at('/data').as('inttest/15')",
		"wrap",
	}); err != nil {
		t.Fatal(err)
	}

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('x').using('inttest/15').run('grep', '123', '/data/a')",
		"x",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 3

File: 15_nested_dirs_test.go Progetto: involucro/involucro

func TestWrapNestedDirsCorrectly(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	dir, err := ioutil.TempDir("", "inttest-15")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	nestedPath := filepath.Join(dir, "asd", "p", "aaa")
	if err := os.MkdirAll(nestedPath, 0755); err != nil {
		t.Fatal(err)
	}

	if err := ioutil.WriteFile(filepath.Join(nestedPath, "a"), []byte("123"), 0755); err != nil {
		t.Fatal(err)
	}
	if err := ioutil.WriteFile(filepath.Join(nestedPath, "b"), []byte("456"), 0755); err != nil {
		t.Fatal(err)
	}

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		c.RemoveImage("inttest/15")
	}()

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('wrap').wrap('.').inImage('busybox').at('/data').as('inttest/15')",
		"-w", dir,
		"wrap",
	}); err != nil {
		t.Fatal(err)
	}

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('x').using('inttest/15').run('grep', '123', '/data/asd/p/aaa/a').run('grep', '456', '/data/asd/p/aaa/b')",
		"x",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 4

File: 26_correctly_handle_files_test.go Progetto: involucro/involucro

func TestFileHandlingSymlinks(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	dir, err := ioutil.TempDir("", "inttest-26")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	if err := os.Mkdir(filepath.Join(dir, "p"), 0755); err != nil {
		t.Fatal(err)
	}

	if err, ok := os.Symlink("../p", filepath.Join(dir, "p", "cur")).(*os.LinkError); ok && err != nil {
		t.Fatal(err)
	}

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}

	args := []string{
		"involucro",
		"-e",
		"inv.task('wrap').wrap('" + dir + "').at('/data').inImage('busybox').as('inttest/26')",
		"wrap",
	}
	defer func() {
		c.RemoveImage("inttest/26")
	}()

	if err := app.Main(args); err != nil {
		t.Fatal(err)
	}

	args = []string{
		"involucro",
		"-e",
		"inv.task('test').using('inttest/26').run('ls', '/data/p/cur/cur/cur/cur')",
		"test",
	}

	if err := app.Main(args); err != nil {
		t.Error(err)
	}
}

Esempio n. 5

File: util_test.go Progetto: involucro/involucro

func assertStdoutContainsFlag(args []string, lineFlag string, t *testing.T) {
	oldPrint := ilog.StdLog.PrintFunc()
	defer ilog.StdLog.SetPrintFunc(oldPrint)

	args = append([]string{"involucro", "-v=2"}, args...)

	var found bool
	ilog.StdLog.SetPrintFunc(func(b ilog.Bough) {
		if testing.Verbose() && oldPrint != nil {
			oldPrint(b)
		}
		if b.Prefix == "SOUT" && b.Message == lineFlag {
			found = true
		}
	})

	if err := app.Main(args); err != nil {
		debug.PrintStack()
		t.Fatal(err)
	}

	if !found {
		t.Error("Did not find expected flag", lineFlag)
	}
}

Esempio n. 6

File: 20_tags_test.go Progetto: involucro/involucro

func TestTagging(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		c.RemoveImage("inttest/20:v1")
		c.RemoveImage("inttest/20_b")
	}()

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('package').wrap('.').inImage('busybox').at('/data').as('inttest/20:v1').tag('inttest/20:v1').as('inttest/20_b')",
		"package",
	}); err != nil {
		t.Fatal(err)
	}

	image, err := c.InspectImage("inttest/20:v1")
	if err != nil {
		t.Fatal(err)
	}

	image2, err := c.InspectImage("inttest/20_b")
	if err != nil {
		t.Fatal(err)
	}

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('run').using('inttest/20:v1').run('true')",
		"run",
	}); err != nil {
		t.Fatal(err)
	}

	if image.ID != image2.ID {
		t.Error("Images do not share an ID", image.ID, image2.ID)
	}
}

Esempio n. 7

File: expectations_test.go Progetto: involucro/involucro

func TestExpectationMatchExitCode(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('test').using('busybox').withExpectation({code = 1}).run('false')",
		"test",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 8

File: expectations_test.go Progetto: involucro/involucro

func TestExpectationMatchStdout(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('test').using('busybox').withExpectation({stdout = 'Hello, World!'}).run('echo', 'Hello, World!')",
		"test",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 9

File: 32_task_list_test.go Progetto: involucro/involucro

func TestTaskListWithTasksAndDirectScript(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	testStdoutOf(func() error {
		return app.Main([]string{
			"involucro", "-e",
			"inv.task('a').using('busybox').run('x'); inv.task('b').using('busybox').run('z')",
			"--tasks",
		})
	}, "a\nb\n", t)
}

Esempio n. 10

File: main.go Progetto: involucro/involucro

func main() {
	err := app.Main(os.Args)

	switch err {
	case flag.ErrHelp:
		os.Exit(0)
	case nil:
		os.Exit(0)
	default:
		ilog.Error.Logf("Task processing failed: %s", err)
		os.Exit(1)
	}
}

Esempio n. 11

File: expectations_test.go Progetto: involucro/involucro

func TestExpectationsCrashesWhenExitCodeNotMet(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('test').using('busybox').withExpectation({code = 1}).run('true')",
		"test",
	}); err == nil {
		t.Error("Expected error")
	}
}

Esempio n. 12

File: expectations_test.go Progetto: involucro/involucro

func TestExpectationsCrashesWhenStderrNotMet(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('test').using('busybox').withExpectation({stderr = 'Hello, World'}).run('/bin/sh', '-c', 'echo Hello, Moon 1>&2')",
		"test",
	}); err == nil {
		t.Error("Expected error")
	}
}

Esempio n. 13

File: 12_runtask_test.go Progetto: involucro/involucro

func TestRuntaskOtherTaskNotPresent(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('test').runTask('udef')",
		"test",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 14

File: 14_wrapoptions_test.go Progetto: involucro/involucro

func TestWrapOptionSetEntrypoint(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		c.RemoveImage("inttest/14")
	}()

	cases := []string{
		"inv.task('wrap').wrap('.').inImage('busybox').at('/data').withConfig({Entrypoint = {'/bin/echo', 'Hello_Options'}}).as('inttest/14')",
		"inv.task('wrap').wrap('.').at('/data').withConfig({Entrypoint = {'/bin/echo', 'Hello_Options'}}).as('inttest/14')",
		"inv.task('wrap').wrap('.').inImage('alpine').at('/data').withConfig({Entrypoint = {'/bin/echo', 'Hello_Options'}}).as('inttest/14')",
	}

	for index, el := range cases {
		if err := app.Main([]string{"involucro", "-e", el, "wrap"}); err != nil {
			t.Error(err)
		}

		image, err := c.InspectImage("inttest/14")
		if err != nil {
			t.Fatalf("Test case %v failed with %v", index, err)
		}
		if image == nil {
			t.Error("Image is nil")
		}
		if image.Config == nil {
			t.Error("Image Config is nil")
		}
		if len(image.Config.Entrypoint) != 2 {
			t.Error("Unexpected entrypoint", image.Config.Entrypoint)
		}
		if image.Config.Entrypoint[0] != "/bin/echo" {
			t.Error("Unexpected first entrypoint element", image.Config.Entrypoint[0])
		}
		if image.Config.Entrypoint[1] != "Hello_Options" {
			t.Error("Unexpected first entrypoint element", image.Config.Entrypoint[0])
		}

		if err := c.RemoveImage("inttest/14"); err != nil {
			t.Error("Unable to remove image", err)
		}
	}
}

Esempio n. 15

File: 04_parameters_test.go Progetto: involucro/involucro

func TestParametersRejectBothInlineScriptAndFilename(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	if err := app.Main([]string{
		"involucro",
		"-e",
		"inv.task('test').runTask('udef')",
		"-f",
		"custom-invfile.lua",
		"test",
	}); err == nil {
		t.Error("Did not fail")
	}
}

Esempio n. 16

File: autopull_test.go Progetto: involucro/involucro

func TestAutopullImage(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	c.RemoveImage("tianon/true")

	if err := app.Main([]string{
		"involucro", "-e",
		"inv.task('test').using('tianon/true').run()",
		"test",
	}); err != nil {
		t.Error(err)
	}
}

Esempio n. 17

File: flexible_mount_dir_test.go Progetto: involucro/involucro

func TestFlexibleMountDirs(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	pwd, err := filepath.Abs(".")
	if err != nil {
		t.Fatal(err)
	}

	cases := []string{
		"./int21:/ttt",
		pwd + "/int21:/ttt",
	}

	if err := os.MkdirAll("int21", 0755); err != nil {
		t.Fatal(err)
	}

	for _, el := range cases {
		if err := ioutil.WriteFile(filepath.Join(pwd, "int21", "testfile"), []byte{0}, 0755); err != nil {
			t.Error("case failed", err)
			continue
		}

		if err := app.Main([]string{
			"involucro", "-e",
			"inv.task('p').using('busybox').withHostConfig({Binds = {'" + el + "'}}).run('rm', '/ttt/testfile')",
			"p",
		}); err != nil {
			t.Fatal(err)
		}

		if _, err := os.Stat(filepath.Join(pwd, "int21", "testfile")); (err == nil) || (!os.IsNotExist(err)) {
			t.Error("Unexpected error", err)
		}
	}
}

Esempio n. 18

File: 16_from_scratch_test.go Progetto: involucro/involucro

func TestFromScratchWithoutParentImage(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal("Unexpected error", err)
	}

	args := []string{
		"involucro",
		"-e",
		"inv.task('package').wrap('.').at('/').as('inttest/16')",
		"package",
	}

	defer func() {
		c.RemoveImage("inttest/16")
	}()

	if err := app.Main(args); err != nil {
		t.Fatal(err)
	}

	history, err := c.ImageHistory("inttest/16")
	if err != nil {
		t.Fatal(err)
	}

	if len(history) != 2 {
		t.Fatal("Unexpected history length, was expecting 2", len(history))
	}

	if history[0].Size != 0 {
		t.Error("Top-most layer is not config-only, but has size", history[0].Size)
	}
}

Esempio n. 19

File: remote_docker_test.go Progetto: involucro/involucro

func TestRemoteWrappableViaTcp(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	if err := os.MkdirAll("fixture_09", 0755); err != nil {
		t.Fatal(err)
	}
	if err := ioutil.WriteFile("fixture_09/asd", []byte("blahblubb\n"), 0200); err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll("fixture_09")

	ln, err := net.Listen("tcp4", "127.0.0.1:4243")
	if err != nil {
		t.Fatal(err)
	}

	defer ln.Close()
	go func() {
		for {
			c, err := ln.Accept()
			if err != nil {
				break
			}
			defer c.Close()

			upstream, err := net.Dial("unix", "/var/run/docker.sock")
			if err != nil {
				break
			}

			go func(c, upstream net.Conn) {
				defer upstream.Close()
				io.Copy(c, upstream)
			}(c, upstream)

			go func(c, upstream net.Conn) {
				defer c.Close()
				io.Copy(upstream, c)
			}(c, upstream)
		}
	}()

	c, err := docker.NewClientFromEnv()
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		c.RemoveImage("inttest/9")
	}()

	pwd, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}

	if err := app.Main([]string{
		"involucro", "-H", "tcp://127.0.0.1:4243", "-v=2",
		"-w", pwd, "-e",
		"inv.task('wrap').wrap('fixture_09').at('/blah').inImage('busybox').as('inttest/9')",
		"wrap",
	}); err != nil {
		t.Fatal(err)
	}

	_, err = c.InspectImage("inttest/9")
	if err != nil {
		t.Fatal(err)
	}

	assertStdoutContainsFlag([]string{
		"-e", "inv.task('a').using('inttest/9').run('/bin/cat', '/blah/asd')", "a",
	}, "blahblubb", t)
}