func ExecuteSpecs(inParallel bool, args []string) int {
if checkUpdatesDuringExecution && config.CheckUpdates() {
i := &install.UpdateFacade{}
i.BufferUpdateDetails()
defer i.PrintUpdateBuffer()
}
env.LoadEnv(false)
specsToExecute, conceptsDictionary := parseSpecs(args)
manifest, err := manifest.ProjectManifest()
if err != nil {
logger.Fatal(err.Error())
}
runner := startApi()
errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
pluginHandler := plugin.StartPlugins(manifest)
parallelInfo := ¶llelInfo{inParallel: inParallel, numberOfStreams: NumberOfExecutionStreams}
if !parallelInfo.isValid() {
os.Exit(1)
}
execution := newExecution(&executionInfo{manifest, specsToExecute, runner, pluginHandler, parallelInfo, reporter.Current(), errMap})
result := execution.start()
execution.finish()
exitCode := printExecutionStatus(result, errMap)
return exitCode
}
func InstallAllPlugins() {
manifest, err := manifest.ProjectManifest()
if err != nil {
logger.Fatal(err.Error())
}
installPluginsFromManifest(manifest)
}
func InstallPluginZip(zipFile string, pluginName string) {
if err := installPluginFromZip(zipFile, pluginName); err != nil {
logger.Fatal("Failed to install plugin. %s\n", err.Error())
} else {
logger.Info("Successfully installed plugin from file.")
}
}
func DownloadAndInstallPlugin(plugin, version, messageFormat string) {
err := downloadAndInstall(plugin, version, fmt.Sprintf(messageFormat, plugin))
if err != nil {
logger.Fatal(err.Error())
}
os.Exit(0)
}
func validateTagExpression(tagExpression string) {
filter := &ScenarioFilterBasedOnTags{tagExpression: tagExpression}
filter.replaceSpecialChar()
_, err := filter.formatAndEvaluateExpression(make(map[string]bool, 0), func(a map[string]bool, b string) bool { return true })
if err != nil {
logger.Fatal(err.Error())
}
}
// Loading default environment and loading user specified env
// this way user specified env variable can override default if required
func LoadEnv(shouldSkip bool) {
err := loadEnvironment(envDefaultDirName)
if err != nil {
if !shouldSkip {
logger.Fatal("Failed to load the default environment. %s\n", err.Error())
}
}
if ProjectEnv != envDefaultDirName {
err := loadEnvironment(ProjectEnv)
if err != nil {
if !shouldSkip {
logger.Fatal("Failed to load the environment: %s. %s\n", ProjectEnv, err.Error())
}
}
CurrentEnv = ProjectEnv
}
}
// InitializeProject initializes a Gauge project with specified template
func InitializeProject(templateName string) {
wd, err := os.Getwd()
if err != nil {
logger.Fatal("Failed to find working directory. %s", err.Error())
}
config.ProjectRoot = wd
exists, _ := common.UrlExists(getTemplateURL(templateName))
if exists {
err = initializeTemplate(templateName)
} else {
err = createProjectTemplate(templateName)
}
if err != nil {
logger.Fatal("Failed to initialize. %s", err.Error())
}
logger.Info("\nSuccessfully initialized the project. Run specifications with \"gauge specs/\"")
}
func startApi() *runner.TestRunner {
startChan := &runner.StartChannels{RunnerChan: make(chan *runner.TestRunner), ErrorChan: make(chan error), KillChan: make(chan bool)}
go api.StartAPIService(0, startChan)
select {
case runner := <-startChan.RunnerChan:
return runner
case err := <-startChan.ErrorChan:
logger.Fatal("Failed to start gauge API: %s", err.Error())
}
return nil
}
func runAPIServiceIndefinitely(port int, wg *sync.WaitGroup) {
wg.Add(1)
startChan := &runner.StartChannels{RunnerChan: make(chan *runner.TestRunner), ErrorChan: make(chan error), KillChan: make(chan bool)}
go StartAPIService(port, startChan)
select {
case runner := <-startChan.RunnerChan:
runner.Kill()
case err := <-startChan.ErrorChan:
logger.Fatal(err.Error())
}
}
func RunInBackground(apiPort string) {
var port int
var err error
if apiPort != "" {
port, err = strconv.Atoi(apiPort)
if err != nil {
logger.Fatal(fmt.Sprintf("Invalid port number: %s", apiPort))
}
os.Setenv(common.APIPortEnvVariableName, apiPort)
} else {
env.LoadEnv(false)
port, err = conn.GetPortFromEnvironmentVariable(common.APIPortEnvVariableName)
if err != nil {
logger.Fatal(fmt.Sprintf("Failed to start API Service. %s \n", err.Error()))
}
}
var wg sync.WaitGroup
runAPIServiceIndefinitely(port, &wg)
wg.Wait()
}
func InstallPluginZip(zipFile string, pluginName string) {
tempDir := common.GetTempDir()
unzippedPluginDir, err := common.UnzipArchive(zipFile, tempDir)
defer common.Remove(tempDir)
if err != nil {
common.Remove(tempDir)
logger.Fatal("Failed to install plugin. %s\n", err.Error())
}
logger.Info("Plugin unzipped to => %s\n", unzippedPluginDir)
hasPluginJSON := common.FileExists(filepath.Join(unzippedPluginDir, pluginJSON))
if hasPluginJSON {
err = installPluginFromDir(unzippedPluginDir)
} else {
err = installRunnerFromDir(unzippedPluginDir, pluginName)
}
if err != nil {
common.Remove(tempDir)
logger.Fatal("Failed to install plugin. %s\n", err.Error())
}
logger.Info("Successfully installed plugin from file.")
}
// SetWorkingDir sets the current working directory to specified location
func SetWorkingDir(workingDir string) {
targetDir, err := filepath.Abs(workingDir)
if err != nil {
logger.Fatal("Unable to set working directory : %s", err.Error())
}
if !common.DirExists(targetDir) {
err = os.Mkdir(targetDir, 0777)
if err != nil {
logger.Fatal("Unable to set working directory : %s", err.Error())
}
}
err = os.Chdir(targetDir)
if err != nil {
logger.Fatal("Unable to set working directory : %s", err.Error())
}
_, err = os.Getwd()
if err != nil {
logger.Fatal("Unable to set working directory : %s", err.Error())
}
}
func AddPluginToProject(pluginName string, pluginArgs string) {
additionalArgs := make(map[string]string)
if pluginArgs != "" {
// plugin args will be comma separated values
// eg: version=1.0, foo_version = 2.41
args := strings.Split(pluginArgs, ",")
for _, arg := range args {
keyValuePair := strings.Split(arg, "=")
if len(keyValuePair) == 2 {
additionalArgs[strings.TrimSpace(keyValuePair[0])] = strings.TrimSpace(keyValuePair[1])
}
}
}
manifest, err := manifest.ProjectManifest()
if err != nil {
logger.Fatal(err.Error())
}
if err := addPluginToTheProject(pluginName, additionalArgs, manifest); err != nil {
logger.Fatal(fmt.Sprintf("Failed to add plugin %s to project : %s\n", pluginName, err.Error()))
} else {
logger.Info("Plugin %s was successfully added to the project\n", pluginName)
}
}
func ParseAndValidateSpecs(args []string) {
env.LoadEnv(false)
specsToExecute, conceptsDictionary := parseSpecs(args)
manifest, err := manifest.ProjectManifest()
if err != nil {
logger.Fatal(err.Error())
}
runner := startApi()
errMap := validateSpecs(manifest, specsToExecute, runner, conceptsDictionary)
runner.Kill()
if len(errMap.stepErrs) > 0 {
os.Exit(1)
}
logger.Info("No error found.")
os.Exit(0)
}
func handleUninstallFailure(err error, pluginName string) {
logger.Error("%s plugin uninstallation failed", pluginName)
logger.Fatal(err.Error())
}