How to use executeSpecs method of execution Package

1package cmd2import (3	"bytes"4	"fmt"5	"os"6	"os/exec"7	"path/filepath"8	"testing"9	"github.com/getgauge/gauge/execution"10	"github.com/getgauge/gauge/execution/rerun"11	"github.com/spf13/pflag"12	"reflect"13	"github.com/getgauge/gauge/config"14	"github.com/spf13/cobra"15)16var path = ""17func before() {18	path, _ = filepath.Abs("_testData")19	config.ProjectRoot = path20}21func after() {22	os.RemoveAll(path)23}24func TestMain(m *testing.M) {25	before()26	runTests := m.Run()27	after()28	os.Exit(runTests)29}30func TestSaveCommandArgs(t *testing.T) {31	if os.Getenv("TEST_EXITS") == "1" {32		args := []string{"gauge", "run", "specs"}33		rerun.WritePrevArgs(args)34		prevArgs := rerun.ReadPrevArgs()35		if !reflect.DeepEqual(prevArgs, args) {36			fmt.Printf("Expected %v  Got %v\n", args, prevArgs)37			os.Exit(1)38		}39		return40	}41	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))42	cmd.Env = subEnv()43	err := cmd.Run()44	if err != nil {45		t.Fatalf("process ran with err %v, want exit status 0", err)46	}47}48func TestExecuteWritesPrevCommandArgs(t *testing.T) {49	if os.Getenv("TEST_EXITS") == "1" {50		args := []string{"gauge", "run", "specs"}51		installPlugins = false52		execution.ExecuteSpecs = func(s []string) int { return 0 }53		cmd := &cobra.Command{}54		os.Args = args55		execute(cmd, args)56		prevArgs := rerun.ReadPrevArgs()57		if !reflect.DeepEqual(prevArgs, args) {58			fmt.Printf("Expected %v  Got %v\n", args, prevArgs)59			os.Exit(1)60		}61		return62	}63	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))64	cmd.Env = subEnv()65	err := cmd.Run()66	if err != nil {67		t.Fatalf("process ran with err %v, want exit status 0", err)68	}69}70func TestRepeatShouldPreservePreviousArgs(t *testing.T) {71	if os.Getenv("TEST_EXITS") == "1" {72		cmd := &cobra.Command{}73		var called bool74		rerun.WritePrevArgs = func(x []string) {75			called = true76		}77		rerun.ReadPrevArgs = func() []string {78			return []string{"gauge", "run", "specs", "-l", "debug"}79		}80		installPlugins = false81		repeatLastExecution(cmd)82		if called {83			panic("Unexpected call to writePrevArgs while repeat")84		}85		return86	}87	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))88	cmd.Env = subEnv()89	err := cmd.Run()90	if err != nil {91		t.Fatalf("process ran with err %v, want exit status 0", err)92	}93}94func TestSaveCommandArgsForFailed(t *testing.T) {95	if os.Getenv("TEST_EXITS") == "1" {96		execution.ExecuteSpecs = func(s []string) int { return 0 }97		rerun.GetLastFailedState = func() ([]string, error) {98			return []string{"run", "specs"}, nil99		}100		var args = []string{"gauge", "run", "--failed"}101		rerun.WritePrevArgs = func(a []string) {102			if !reflect.DeepEqual(a, args) {103				panic(fmt.Sprintf("Expected %v  Got %v", args, a))104			}105		}106		os.Args = args107		executeFailed(runCmd)108		return109	}110	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))111	cmd.Env = subEnv()112	err := cmd.Run()113	if err != nil {114		t.Fatalf("process ran with err %v, want exit status 0", err)115	}116}117func TestHandleConflictingParamsWithOtherArguments(t *testing.T) {118	if os.Getenv("TEST_EXITS") == "1" {119		args := []string{"specs"}120		var flags = pflag.FlagSet{}121		flags.BoolP("repeat", "r", false, "")122		flags.Set("repeat", "true")123		repeat = true124		expectedErrorMessage := "Invalid Command. Usage: gauge run --repeat"125		err := handleConflictingParams(&flags, args)126		if !reflect.DeepEqual(err.Error(), expectedErrorMessage) {127			fmt.Printf("Expected %v  Got %v\n", expectedErrorMessage, err)128			panic("assert failed")129		}130		return131	}132	var stdout bytes.Buffer133	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))134	cmd.Env = subEnv()135	cmd.Stdout = &stdout136	err := cmd.Run()137	if err != nil {138		t.Fatalf("process ran with err %v, want exit status 0. Stdout:\n%s", err, stdout.Bytes())139	}140}141func TestHandleConflictingParamsWithOtherFlags(t *testing.T) {142	args := []string{}143	var flags = pflag.FlagSet{}144	flags.BoolP("repeat", "r", false, "")145	flags.Set("repeat", "true")146	flags.StringP("tags", "", "", "")147	flags.Set("tags", "abcd")148	repeat = true149	expectedErrorMessage := "Invalid Command. Usage: gauge run --repeat"150	err := handleConflictingParams(&flags, args)151	if !reflect.DeepEqual(err.Error(), expectedErrorMessage) {152		t.Errorf("Expected %v  Got %v", expectedErrorMessage, err)153	}154}155func TestHandleConflictingParamsWithJustRepeatFlag(t *testing.T) {156	args := []string{}157	var flags = pflag.FlagSet{}158	flags.BoolP("repeat", "r", false, "")159	flags.Set("repeat", "true")160	repeat = true161	err := handleConflictingParams(&flags, args)162	if err != nil {163		t.Errorf("Expected %v  Got %v", nil, err.Error())164	}165}166func TestHandleRerunFlagsWithVerbose(t *testing.T) {167	if os.Getenv("TEST_EXITS") == "1" {168		cmd := &cobra.Command{}169		cmd.Flags().BoolP(verboseName, "v", verboseDefault, "Enable step level reporting on console, default being scenario level")170		cmd.Flags().BoolP(simpleConsoleName, "", simpleConsoleDefault, "Removes colouring and simplifies the console output")171		cmd.Flags().StringP(environmentName, "e", environmentDefault, "Specifies the environment to use")172		cmd.Flags().StringP(tagsName, "t", tagsDefault, "Executes the specs and scenarios tagged with given tags")173		cmd.Flags().StringP(rowsName, "r", rowsDefault, "Executes the specs and scenarios only for the selected rows. It can be specified by range as 2-4 or as list 2,4")174		cmd.Flags().BoolP(parallelName, "p", parallelDefault, "Execute specs in parallel")175		cmd.Flags().IntP(streamsName, "n", streamsDefault, "Specify number of parallel execution streams")176		cmd.Flags().IntP(groupName, "g", groupDefault, "Specify which group of specification to execute based on -n flag")177		cmd.Flags().StringP(strategyName, "", strategyDefault, "Set the parallelization strategy for execution. Possible options are: `eager`, `lazy`")178		cmd.Flags().BoolP(sortName, "s", sortDefault, "Run specs in Alphabetical Order")179		cmd.Flags().BoolP(installPluginsName, "i", installPluginsDefault, "Install All Missing Plugins")180		cmd.Flags().BoolP(failedName, "f", failedDefault, "Run only the scenarios failed in previous run. This is an exclusive flag, it cannot be used in conjunction with any other argument")181		cmd.Flags().BoolP(repeatName, "", repeatDefault, "Repeat last run. This is an exclusive flag, it cannot be used in conjunction with any other argument")182		cmd.Flags().BoolP(hideSuggestionName, "", hideSuggestionDefault, "Prints a step implementation stub for every unimplemented step")183		cmd.Flags().Set(repeatName, "true")184		cmd.Flags().Set(verboseName, "true")185		handleFlags(cmd, []string{"--repeat", "--verbose"})186		overridenFlagValue := cmd.Flag(verboseName).Value.String()187		expectedFlag := "true"188		if !reflect.DeepEqual(overridenFlagValue, expectedFlag) {189			fmt.Printf("Expected %v Got %v\n", expectedFlag, overridenFlagValue)190			os.Exit(1)191		}192		return193	}194	var stdout bytes.Buffer195	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))196	cmd.Env = subEnv()197	cmd.Stdout = &stdout198	err := cmd.Run()199	if err != nil {200		t.Fatalf("process ran with err %v, want exit status 0. Stdout:\n%s", err, stdout.Bytes())201	}202}203func TestHandleFailedCommandForNonGaugeProject(t *testing.T) {204	if os.Getenv("TEST_EXITS") == "1" {205		config.ProjectRoot = ""206		currDir, _ := os.Getwd()207		defer os.Chdir(currDir)208		testdir := filepath.Join(currDir, "dotGauge")209		dotgaugeDir := filepath.Join(testdir, ".gauge")210		os.Chdir(testdir)211		exit = func(err error, i string) {212			if _, e := os.Stat(dotgaugeDir); os.IsExist(e) {213				panic("Folder .gauge is created")214			}215			os.Exit(0)216		}217		os.Args = []string{"gauge", "run", "-f"}218		runCmd.Execute()219		return220	}221	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))222	cmd.Env = subEnv()223	err := cmd.Run()224	if err != nil {225		t.Fatalf("process ran with err %v, want exit status 0", err)226	}227}228func TestHandleConflictingParamsWithLogLevelFlag(t *testing.T) {229	args := []string{}230	var flags = pflag.FlagSet{}231	flags.StringP("log-level", "l", "info", "")232	flags.Set("log-level", "debug")233	flags.BoolP("repeat", "r", false, "")234	flags.Set("repeat", "true")235	repeat = true236	err := handleConflictingParams(&flags, args)237	if err != nil {238		t.Errorf("Expected %v  Got %v", nil, err.Error())239	}240}241func TestNoExitCodeShouldForceReturnZero(t *testing.T) {242	if os.Getenv("TEST_EXITS") == "1" {243		installPlugins = false244		// simulate failure245		execution.ExecuteSpecs = func(s []string) int { return execution.ExecutionFailed }246		os.Args = []string{"gauge", "run", "--fail-safe", "specs"}247		failSafe = true248		runCmd.Execute()249		return250	}251	var stdout bytes.Buffer252	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))253	cmd.Env = subEnv()254	cmd.Stdout = &stdout255	err := cmd.Run()256	if err != nil {257		t.Fatalf("%s process ran with err %v, want exit status 0. Stdout:\n%s", os.Args, err, stdout.Bytes())258	}259}260func TestFailureShouldReturnExitCodeForParseErrors(t *testing.T) {261	if os.Getenv("TEST_EXITS") == "1" {262		// simulate parse failure263		execution.ExecuteSpecs = func(s []string) int { return execution.ParseFailed }264		os.Args = []string{"gauge", "run", "--fail-safe", "specs"}265		failSafe = true266		runCmd.Execute()267	}268	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))269	cmd.Env = append(os.Environ(), "TEST_EXITS=1")270	err := cmd.Run()271	if e, ok := err.(*exec.ExitError); ok && !e.Success() {272		return273	}274	t.Fatalf("process ran with err %v, want exit status 2", err)275}276func TestFailureShouldReturnExitCode(t *testing.T) {277	if os.Getenv("TEST_EXITS") == "1" {278		// simulate execution failure279		execution.ExecuteSpecs = func(s []string) int { return execution.ExecutionFailed }280		os.Args = []string{"gauge", "run", "specs"}281		runCmd.Execute()282	}283	var stdout bytes.Buffer284	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))285	cmd.Env = subEnv()286	cmd.Stdout = &stdout287	err := cmd.Run()288	if e, ok := err.(*exec.ExitError); ok && !e.Success() {289		return290	}291	t.Fatalf("process ran with err %v, want exit status 1. Stdout:\n%s", err, stdout.Bytes())292}293func TestLogLevelCanBeOverriddenForFailed(t *testing.T) {294	if os.Getenv("TEST_EXITS") == "1" {295		// expect log level to be overridden296		execution.ExecuteSpecs = func(s []string) int {297			f, err := runCmd.Flags().GetString(logLevelName)298			if err != nil {299				fmt.Printf("Error parsing flags. %s\n", err.Error())300				panic(err)301			}302			if f != "info" {303				fmt.Printf("Expecting log-level=info, got %s\n", f)304				panic("assert failure")305			}306			return 0307		}308		rerun.ReadPrevArgs = func() []string {309			return []string{"gauge", "run", "specs", "-l", "debug"}310		}311		os.Args = []string{"gauge", "run", "--failed", "-l", "info"}312		executeFailed(runCmd)313		return314	}315	var stdout bytes.Buffer316	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))317	cmd.Env = subEnv()318	cmd.Stdout = &stdout319	err := cmd.Run()320	if err != nil {321		t.Fatalf("process ran with err %v, want exit status 0.Stdout:\n%s", err, stdout.Bytes())322	}323}324func TestLogLevelCanBeOverriddenForRepeat(t *testing.T) {325	if os.Getenv("TEST_EXITS") == "1" {326		// expect log level to be overridden327		execution.ExecuteSpecs = func(s []string) int {328			f, err := runCmd.Flags().GetString(logLevelName)329			if err != nil {330				fmt.Printf("Error parsing flags. %s\n", err.Error())331				panic(err)332			}333			if f != "info" {334				fmt.Printf("Expecting log-level=info, got %s\n", f)335				panic("assert failure")336			}337			return 0338		}339		rerun.ReadPrevArgs = func() []string {340			return []string{"gauge", "run", "specs", "-l=debug"}341		}342		os.Args = []string{"gauge", "run", "--failed", "-l=info"}343		runCmd.ParseFlags(os.Args)344		repeatLastExecution(runCmd)345		return346	}347	var stdout bytes.Buffer348	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()), "-test.v")349	cmd.Env = subEnv()350	cmd.Stdout = &stdout351	err := cmd.Run()352	if err != nil {353		t.Fatalf("process ran with err %v, want exit status 0.Stdout:\n%s", err, stdout.Bytes())354	}355}356func TestCorrectFlagsAreSetForRepeat(t *testing.T) {357	if os.Getenv("TEST_EXITS") == "1" {358		// expect "env" to be set to "test"359		execution.ExecuteSpecs = func(s []string) int {360			f, err := runCmd.Flags().GetString(environmentName)361			if err != nil {362				fmt.Printf("Error parsing flags. %s\n", err.Error())363				panic(err)364			}365			if f != "test" {366				fmt.Printf("Expecting env=test, got %s\n", f)367				panic("assert failure")368			}369			return 0370		}371		rerun.ReadPrevArgs = func() []string {372			return []string{"gauge", "run", "specs", "--env=test"}373		}374		os.Args = []string{"gauge", "run", "--failed"}375		runCmd.ParseFlags(os.Args)376		repeatLastExecution(runCmd)377		return378	}379	var stdout bytes.Buffer380	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))381	cmd.Env = subEnv()382	cmd.Stdout = &stdout383	err := cmd.Run()384	if err != nil {385		t.Fatalf("process ran with err %v, want exit status 0.Stdout:\n%s", err, stdout.Bytes())386	}387}388func TestCorrectFlagsAreSetForFailed(t *testing.T) {389	if os.Getenv("TEST_EXITS") == "1" {390		// expect "env" to be set to "test"391		execution.ExecuteSpecs = func(s []string) int {392			f, err := runCmd.Flags().GetString(environmentName)393			if err != nil {394				fmt.Printf("Error parsing flags. %s\n", err.Error())395				panic(err)396			}397			if f != "test" {398				fmt.Printf("Expecting env=test, got %s\n", f)399				panic("assert failure")400			}401			return 0402		}403		rerun.GetLastFailedState = func() ([]string, error) {404			return []string{"run", "specs", "--env=test"}, nil405		}406		os.Args = []string{"gauge", "run", "--failed"}407		executeFailed(runCmd)408		return409	}410	var stdout bytes.Buffer411	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()), "-test.v")412	cmd.Env = subEnv()413	cmd.Stdout = &stdout414	err := cmd.Run()415	if err != nil {416		t.Fatalf("process ran with err %v, want exit status 0.Stdout:\n%s", err, stdout.Bytes())417	}418}419func subEnv() []string {420	return append(os.Environ(), []string{"TEST_EXITS=1", "GAUGE_PLUGIN_INSTALL=false"}...)421}...

...65		return66	}67	e.notifyBeforeSuite()68	if !e.suiteResult.GetFailed() {69		results := e.executeSpecs(e.specCollection)70		e.suiteResult.AddSpecResults(results)71	}72	e.notifyAfterSuite()73	setResultMeta()74}75func (e *simpleExecution) start() {76	e.startTime = time.Now()77	event.Notify(event.NewExecutionEvent(event.SuiteStart, nil, nil, 0, gauge_messages.ExecutionInfo{}))78	e.pluginHandler = plugin.StartPlugins(e.manifest)79}80func (e *simpleExecution) finish() {81	event.Notify(event.NewExecutionEvent(event.SuiteEnd, nil, e.suiteResult, 0, gauge_messages.ExecutionInfo{}))82	e.notifyExecutionResult()83	e.stopAllPlugins()84}85func (e *simpleExecution) stopAllPlugins() {86	e.notifyExecutionStop()87	if err := e.runner.Kill(); err != nil {88		logger.Errorf("Failed to kill Runner: %s", err.Error())89	}90}91func (e *simpleExecution) executeSpecs(specs *gauge.SpecCollection) []*result.SpecResult {92	var results []*result.SpecResult93	for specs.HasNext() {94		s := specs.Next()95		ex := newSpecExecutor(s, e.runner, e.pluginHandler, e.errMaps, e.stream)96		results = append(results, ex.execute())97	}98	return results99}100func (e *simpleExecution) notifyBeforeSuite() {101	m := &gauge_messages.Message{MessageType: gauge_messages.Message_ExecutionStarting,102		ExecutionStartingRequest: &gauge_messages.ExecutionStartingRequest{}}103	res := e.executeHook(m)104	if res.GetFailed() {105		handleHookFailure(e.suiteResult, res, result.AddPreHook)...

1type Execution struct {2}3func (e Execution) ExecuteSpecs() {4}5import "github.com/execution"6func main() {7    execution.ExecuteSpecs()8}9import "github.com/execution"10func main() {11    execution.ExecuteSpecs()12}13import "github.com/execution"14func main() {15    execution.ExecuteSpecs()16}17import "github.com/execution"18func main() {19    execution.ExecuteSpecs()20}21import "github.com/execution"22func main() {23    execution.ExecuteSpecs()24}

1import (2func main() {3	gauge.ExecuteSpecs(func() {4		fmt.Println("Starting specs")5	})6}7import (8func init() {9	s := spec.New("Sample spec", "Sample description")10	s.AddStep("Say Hello", sayHello)11	s.AddStep("Say Hello to <name>", sayHelloTo)12	testsuit.AddSpec(s)13}14func sayHello() {15	gauge.WriteMessage("Hello world")16}17func sayHelloTo(name string) {18	gauge.WriteMessage("Hello %s", name)19}20import (21func init() {22	h := hook.New("AfterSuite", func() {23		gauge.WriteMessage("After suite")24	})25	testsuit.AddHook(h)26}27import (28func init() {

1import (2func TestHello(t *testing.T) {3	gomega.RegisterFailHandler(ginkgo.Fail)4	junitReporter := reporters.NewJUnitReporter("junit.xml")5	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Hello Suite", []ginkgo.Reporter{junitReporter})6}7var _ = ginkgo.Describe("Hello", func() {8	ginkgo.It("should say hello to the world", func() {9		ginkgo.By("Saying hello")10		fmt.Println("Hello World!")11	})12})13func main() {14	config := config.GinkgoConfigType{15	}16	execution := ginkgo.NewExecution(config)17	specs := execution.GetSpecs()18	execution.ExecuteSpecs(specs, os.Stdout, os.Stdout)19}20import (21func TestHello(t *testing.T) {22	gomega.RegisterFailHandler(ginkgo.Fail)23	junitReporter := reporters.NewJUnitReporter("junit.xml")24	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Hello Suite", []gink

1import (2func main() {3    path, err := gexec.Build("github.com/onsi/ginkgo/examples/ginkgo-example")4    if err != nil {5        fmt.Fprintf(os.Stderr, "Failed to build binary: %s6        os.Exit(1)7    }8    tr := testrunner.New(path, true, 1, config.DefaultReporterConfig)9    specs := []types.SpecSummary{10        types.SpecSummary{

1import (2func main() {3    execution := gauge.NewExecution()4    execution.ExecuteSpecs()5}6import (7func main() {8    execution := gauge.NewExecution()9    execution.ExecuteSpecs()10}11import (12func main() {13    execution := gauge.NewExecution()14    execution.ExecuteSpecs()15}16import (17func main() {18    execution := gauge.NewExecution()19    execution.ExecuteSpecs()20}21import (22func main() {23    execution := gauge.NewExecution()24    execution.ExecuteSpecs()25}26import (27func main() {28    execution := gauge.NewExecution()29    execution.ExecuteSpecs()30}31import (32func main() {33    execution := gauge.NewExecution()34    execution.ExecuteSpecs()35}36import (37func main() {38    execution := gauge.NewExecution()39    execution.ExecuteSpecs()40}41import (

1import (2func main() {3	execution := new(testsuit.Execution)4	suiteResult := testsuit.NewSuiteResult("My Suite")5	specResult := testsuit.NewSpecResult("My Spec")6	scenarioResult := testsuit.NewScenarioResult("My Scenario")7	specResult.AddScenarioResult(scenarioResult)8	suiteResult.AddSpecResult(specResult)9	execution.ExecuteSpecs([]*testsuit.SpecResult{specResult})10	status := execution.GetStatus()11	fmt.Println(status)12	os.Exit(0)13}14import (15func main() {16	execution := new(testsuit.Execution)17	suiteResult := testsuit.NewSuiteResult("My Suite")18	specResult := testsuit.NewSpecResult("My Spec")19	scenarioResult := testsuit.NewScenarioResult("My Scenario")20	specResult.AddScenarioResult(scenarioResult)21	suiteResult.AddSpecResult(specResult)22	execution.ExecuteSpecs([]*testsuit.SpecResult{specResult})23	status := execution.GetStatus()24	fmt.Println(status)25	os.Exit(0)26}27import (28func main() {

1import (2func main() {3	commandParts := strings.Split(command, " ")4	cmd := exec.Command(commandParts[0], commandParts[1:]...)5	output, err := cmd.CombinedOutput()6	if err != nil {7		fmt.Println(err)8	}9	fmt.Println(string(output))