func (a *App) actionTest(rctx router.Context) error {
	ctx := rctx.(*app.Context)

	// Rebuild
	if err := a.actionRebuild(rctx); err != nil {
		return err
	}

	// Verify we have the files
	dir := filepath.Join(filepath.Dir(ctx.Appfile.Path), "_scriptpack_staging")
	if _, err := os.Stat(dir); err != nil {
		return fmt.Errorf(
			"The directory with the built ScriptPack files doesn't exist!\n" +
				"Please build this with `otto dev scriptpack-rebuild` prior to\n" +
				"running tests.")
	}

	// Get the env vars
	f, err := os.Open(filepath.Join(dir, "env"))
	if err != nil {
		return err
	}
	var env map[string]string
	err = json.NewDecoder(f).Decode(&env)
	f.Close()
	if err != nil {
		return err
	}

	// Build the command we execute to run the tests
	cmd := []string{
		"docker",
		"run",
		"-v /vagrant:/devroot",
	}
	for k, v := range env {
		cmd = append(cmd, fmt.Sprintf("-e %s=%s", k, v))
	}
	cmd = append(cmd, "hashicorp/otto-scriptpack-test-ubuntu:14.04")
	cmd = append(cmd, "bats")

	// Determine the test to execute
	testPath := "test"
	if args := rctx.RouteArgs(); len(args) > 0 {
		testPath = args[0]
	}
	if !filepath.IsAbs(testPath) {
		testPath = fmt.Sprintf("/devroot/" + testPath)
	}

	cmd = append(cmd, testPath)

	// Run the command
	ctx.Ui.Header(fmt.Sprintf("Executing: %s", strings.Join(cmd, " ")))
	v := &vagrant.DevOptions{}
	v.Vagrant(ctx).Execute("ssh", "-c", strings.Join(cmd, " "))

	return nil
}

func (opts *DevOptions) actionLayers(rctx router.Context) error {
	if opts.Layer == nil {
		return fmt.Errorf(
			"This development environment does not use layers.\n" +
				"This command can only be used to manage development\n" +
				"environments with layers.")
	}

	ctx := rctx.(*app.Context)
	fs := flag.NewFlagSet("otto", flag.ContinueOnError)
	graph := fs.Bool("graph", false, "show graph")
	prune := fs.Bool("prune", false, "prune unused layers")
	if err := fs.Parse(rctx.RouteArgs()); err != nil {
		return err
	}

	// Graph?
	if *graph {
		graph, err := opts.Layer.Graph()
		if err != nil {
			return err
		}

		ctx.Ui.Raw(graph.String() + "\n")
		return nil
	}

	// Prune?
	if *prune {
		ctx.Ui.Header("Pruning any outdated or unused layers...")
		count, err := opts.Layer.Prune(&ctx.Shared)
		if err != nil {
			return err
		}
		if count == 0 {
			ctx.Ui.Message("No outdated or unused layers were found!")
		} else {
			ctx.Ui.Message(fmt.Sprintf(
				"[green]Pruned %d outdated or unused layers!", count))
		}

		return nil
	}

	// We're just listing the layers. Eventually we probably should
	// output status or something more useful here.
	for _, l := range opts.Layer.Layers {
		ctx.Ui.Raw(l.ID + "\n")
	}

	return nil
}

func (i *Infrastructure) actionApply(rctx router.Context) error {
	rctx.UI().Header("Building main infrastructure...")
	ctx := rctx.(*infrastructure.Context)
	return i.execute(ctx, "apply")
}

func (i *Infrastructure) actionDestroy(rctx router.Context) error {
	rctx.UI().Header("Destroying main infrastructure...")
	ctx := rctx.(*infrastructure.Context)
	return i.execute(ctx, "destroy", "-force")
}