예제 #1
0
func TestCompile_implicit(t *testing.T) {
	dir := fixtureDir("compile-implicit")
	defer os.Remove(filepath.Join(dir, ".ottoid"))
	defer testChdir(t, dir)()

	core := otto.TestCoreConfig(t)
	otto.TestFoundation(t, foundation.Tuple{"consul", "aws", "simple"}, core)
	infra := otto.TestInfra(t, "aws", core)
	appImpl := otto.TestApp(t, app.Tuple{"test", "aws", "simple"}, core)
	childAppImpl := otto.TestApp(t, app.Tuple{"child", "aws", "simple"}, core)

	appImpl.ImplicitResult = &appfile.File{
		Application: &appfile.Application{
			Dependencies: []*appfile.Dependency{
				&appfile.Dependency{
					Source: "child",
				},
			},
		},
	}

	ui := new(cli.MockUi)
	detectors := []*detect.Detector{
		&detect.Detector{
			Type: "test",
			File: []string{"test-file"},
		},
	}

	c := &CompileCommand{
		Meta: Meta{
			CoreConfig: core,
			Ui:         ui,
		},
		Detectors: detectors,
	}

	args := []string{}
	if code := c.Run(args); code != 0 {
		t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
	}

	if !infra.CompileCalled {
		t.Fatal("Compile should be called")
	}
	if !appImpl.CompileCalled {
		t.Fatal("Compile should be called")
	}
	if !childAppImpl.CompileCalled {
		t.Fatal("Compile should be called")
	}
}
예제 #2
0
파일: compile_test.go 프로젝트: rowhit/otto
func TestCompile_appfileDir(t *testing.T) {
	core := otto.TestCoreConfig(t)
	infra := otto.TestInfra(t, "aws", core)
	otto.TestFoundation(t, foundation.Tuple{"consul", "aws", "simple"}, core)
	otto.TestApp(t, app.Tuple{"test", "aws", "simple"}, core)

	ui := new(cli.MockUi)
	detectors := []*detect.Detector{
		&detect.Detector{
			Type: "test",
			File: []string{"main.txt"},
		},
	}

	c := &CompileCommand{
		Meta: Meta{
			CoreConfig: core,
			Ui:         ui,
		},
		Detectors: detectors,
	}

	dir := fixtureDir("compile-appfile-dir")
	defer testChdir(t, dir)()

	args := []string{}
	if code := c.Run(args); code != 0 {
		t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
	}

	if !infra.CompileCalled {
		t.Fatal("Compile should be called")
	}
}
예제 #3
0
파일: compile_test.go 프로젝트: rowhit/otto
func TestCompile(t *testing.T) {
	core := otto.TestCoreConfig(t)
	infra := otto.TestInfra(t, "test", core)
	appImpl := otto.TestApp(t, app.Tuple{"test", "test", "test"}, core)
	ui := new(cli.MockUi)
	c := &CompileCommand{
		Meta: Meta{
			CoreConfig: core,
			Ui:         ui,
		},
	}

	dir := fixtureDir("compile-basic")
	defer os.Remove(filepath.Join(dir, ".ottoid"))
	defer testChdir(t, dir)()

	args := []string{}
	if code := c.Run(args); code != 0 {
		t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
	}

	if !infra.CompileCalled {
		t.Fatal("Compile should be called")
	}
	if !appImpl.CompileCalled {
		t.Fatal("Compile should be called")
	}
}
예제 #4
0
파일: compile_test.go 프로젝트: rowhit/otto
func TestCompile_noExplicitType(t *testing.T) {
	core := otto.TestCoreConfig(t)
	infra := otto.TestInfra(t, "aws", core)
	appImpl := otto.TestApp(t, app.Tuple{"test-detection-merge", "aws", "simple"}, core)
	appImpl.CompileFunc = func(ctx *app.Context) (*app.CompileResult, error) {
		if ctx.Application == nil {
			t.Fatal("application unexpectedly nil")
		}
		if ctx.Application.Name != "compile-no-explicit-type" {
			t.Fatalf("expected: compile-no-explicit-type; got: %s", ctx.Application.Name)
		}
		if ctx.Application.Type != "test-detection-merge" {
			t.Fatalf("expected: test-detection-merge; got: %s", ctx.Application.Type)
		}
		return nil, nil
	}
	foundImpl := otto.TestFoundation(
		t, foundation.Tuple{"consul", "aws", "simple"}, core)
	ui := new(cli.MockUi)
	detectors := []*detect.Detector{
		&detect.Detector{
			Type: "test-detection-merge",
			File: []string{"test-file"},
		},
	}
	c := &CompileCommand{
		Meta: Meta{
			CoreConfig: core,
			Ui:         ui,
		},
		Detectors: detectors,
	}

	dir := fixtureDir("compile-detection")
	defer os.Remove(filepath.Join(dir, ".ottoid"))
	defer testChdir(t, dir)()

	args := []string{}
	if code := c.Run(args); code != 0 {
		t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
	}

	if !infra.CompileCalled {
		t.Fatal("Compile should be called")
	}
	if !appImpl.CompileCalled {
		t.Fatal("Compile should be called")
	}
	if !foundImpl.CompileCalled {
		t.Fatal("Foundation should be called")
	}
}
예제 #5
0
func TestCompile_detectPriority(t *testing.T) {
	core := otto.TestCoreConfig(t)
	otto.TestInfra(t, "aws", core)
	otto.TestFoundation(t, foundation.Tuple{"consul", "aws", "simple"}, core)
	appImpl := otto.TestApp(t, app.Tuple{"test", "aws", "simple"}, core)
	ui := new(cli.MockUi)
	detectors := []*detect.Detector{
		&detect.Detector{
			Type: "invalid",
			File: []string{"test-file"},
		},
		&detect.Detector{
			Type:     "test",
			File:     []string{"test-file"},
			Priority: 10,
		},
	}
	c := &CompileCommand{
		Meta: Meta{
			CoreConfig: core,
			Ui:         ui,
		},
		Detectors: detectors,
	}

	dir := fixtureDir("compile-no-appfile")
	defer os.Remove(filepath.Join(dir, ".ottoid"))
	defer testChdir(t, dir)()

	args := []string{}
	if code := c.Run(args); code != 0 {
		t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
	}

	if !appImpl.CompileCalled {
		t.Fatal("Compile should be called")
	}
}