clean: Remove global variables and move test resources folder

Author: josemiguelmelo

README.md

@@ -30,8 +30,6 @@ Then, on the main function you just need to instantiate it and pass to engine's
 As an example:
 
 ```
-
-
 // GoTool tool implementation
 type GoTool struct {
 }

configuration_test.go

@@ -2,11 +2,14 @@ package codacytool
 
 import (
 	"github.com/stretchr/testify/assert"
+	"path/filepath"
 	"testing"
 )
 
+const configurationTestResources = "configuration"
+
 func TestParseConfiguration(t *testing.T) {
-	location := testsResourcesLocation + "/.codacyrc"
+	location := filepath.Join(testsResourcesLocation, configurationTestResources, ".codacyrc.valid")
 
 	configuration, err := ParseConfiguration(location)
 
@@ -16,3 +19,28 @@ func TestParseConfiguration(t *testing.T) {
 	got := len(configuration.Files)
 	assert.Equal(t, expected, got)
 }
+
+func TestParseInvalidConfiguration(t *testing.T) {
+	location := filepath.Join(testsResourcesLocation, configurationTestResources, ".codacyrc.invalid")
+	configuration, err := ParseConfiguration(location)
+
+	assert.Nil(t, err)
+
+	// Files is present
+	expected := 2
+	got := len(configuration.Files)
+	assert.Equal(t, expected, got)
+
+	// Tools has a typo, so it must not parse it and return 0 tools
+	expected = 0
+	got = len(configuration.Tools)
+	assert.Equal(t, expected, got)
+}
+
+func TestParseNonExistingConfiguration(t *testing.T) {
+	location := filepath.Join(testsResourcesLocation, configurationTestResources, ".codacyrc.notexists")
+
+	_, err := ParseConfiguration(location)
+
+	assert.NotNil(t, err)
+}

configurationfiles.go

@@ -1,30 +1,30 @@
 package codacytool
 
+import (
+	"path/filepath"
+)
+
 const (
 	toolFilesBasePath         = "/"
 	defaultDefinitionFileName = "docs/patterns.json"
 	defaultConfigFileName     = ".codacyrc"
 )
 
-func getBasePath() string {
-	var basePathFromEnv string
-	if toolConfigsBasePathFlag != nil {
-		basePathFromEnv = *toolConfigsBasePathFlag
-	}
-	if basePathFromEnv != "" {
-		return basePathFromEnv
+func getBasePath(toolConfigsBasePath string) string {
+	if toolConfigsBasePath != "" {
+		return toolConfigsBasePath
 	}
 	return toolFilesBasePath
 }
 
-func getPathToFile(file string) string {
-	return getBasePath() + file
+func getPathToFile(toolConfigsBasePath string, file string) string {
+	return filepath.Join(getBasePath(toolConfigsBasePath), file)
 }
 
-func defaultDefinitionFile() string {
-	return getPathToFile(defaultDefinitionFileName)
+func defaultDefinitionFile(toolConfigsBasePath string) string {
+	return getPathToFile(toolConfigsBasePath, defaultDefinitionFileName)
 }
 
-func defaultConfigurationFile() string {
-	return getPathToFile(defaultConfigFileName)
+func defaultConfigurationFile(toolConfigsBasePath string) string {
+	return getPathToFile(toolConfigsBasePath, defaultConfigFileName)
 }

configurationfiles_test.go

@@ -2,29 +2,32 @@ package codacytool
 
 import (
 	"github.com/stretchr/testify/assert"
+	"path/filepath"
 	"testing"
 )
 
+const basePath = "/"
+
 func TestGetBasePath(t *testing.T) {
-	basePath := getBasePath()
+	basePath := getBasePath(basePath)
 	assert.Equal(t, toolFilesBasePath, basePath)
 }
 
 func TestGetPathToFile(t *testing.T) {
 	file := "/file"
-	expectedPath := getBasePath() + file
-	path := getPathToFile(file)
+	expectedPath := filepath.Join(getBasePath(basePath), file)
+	path := getPathToFile(basePath, file)
 	assert.Equal(t, expectedPath, path)
 }
 
 func TestDefaultDefinitionFile(t *testing.T) {
-	expectedPath := getPathToFile(defaultDefinitionFileName)
-	path := defaultDefinitionFile()
+	expectedPath := getPathToFile(basePath, defaultDefinitionFileName)
+	path := defaultDefinitionFile(basePath)
 	assert.Equal(t, expectedPath, path)
 }
 
 func TestDefaultConfigurationFile(t *testing.T) {
-	expectedPath := getPathToFile(defaultConfigFileName)
-	path := defaultConfigurationFile()
+	expectedPath := getPathToFile(basePath, defaultConfigFileName)
+	path := defaultConfigurationFile(basePath)
 	assert.Equal(t, expectedPath, path)
 }

global_tests.go

@@ -1,3 +1,3 @@
 package codacytool
 
-var testsResourcesLocation = "./resources/tests/"
+var testsResourcesLocation = "./tests/"

go.sum

@@ -7,34 +7,40 @@ import (
 	"time"
 )
 
-var (
-	sourceDirFlag           *string
-	toolConfigsBasePathFlag *string
-)
+// RunConfiguration contains the process run configuration
+type RunConfiguration struct {
+	sourceDir           string
+	toolConfigsBasePath string
+	timeoutDuration     time.Duration
+}
 
 const (
 	defaultTimeout = 15 * time.Minute
 )
 
 // StartTool receives the tool implementation as parameter and run the tool
 func StartTool(impl ToolImplementation) {
-	parseFlags()
+	cmdLineConfig := parseFlags()
 
-	runWithTimeout(impl, timeoutSeconds())
+	runWithTimeout(impl, cmdLineConfig)
 }
 
-func runWithTimeout(impl ToolImplementation, maxDuration time.Duration) {
+func runWithTimeout(impl ToolImplementation, runConfiguration RunConfiguration) {
 	runMethodWithTimeout(func() {
-		startToolImplementation(impl, *sourceDirFlag)
+		startToolImplementation(impl, runConfiguration)
 	}, func() {
-		fmt.Fprintf(os.Stderr, "Timeout of %s seconds exceeded", maxDuration)
+		fmt.Fprintf(os.Stderr, "Timeout of %s seconds exceeded", runConfiguration.timeoutDuration)
 		os.Exit(1)
-	}, maxDuration)
+	}, runConfiguration.timeoutDuration)
 }
 
-func parseFlags() {
-	sourceDirFlag = flag.String("sourceDir", "/src", "source to analyse folder")
-	toolConfigsBasePathFlag = flag.String("toolConfigLocation", "/", "Location of tool configuration")
+func parseFlags() RunConfiguration {
+	cmdLineConfig := RunConfiguration{
+		sourceDir:           *flag.String("sourceDir", "/src", "source to analyse folder"),
+		toolConfigsBasePath: *flag.String("toolConfigLocation", "/", "Location of tool configuration"),
+		timeoutDuration:     timeoutSeconds(),
+	}
 
 	flag.Parse()
+	return cmdLineConfig
 }

init.go

@@ -0,0 +1,19 @@
+{
+  "files" : ["foo/bar/baz.go", "foo2/bar/baz.go"],
+  "tool":[
+    {
+      "name":"govet",
+      "patterns":[
+        {
+          "patternId":"govet",
+          "parameters":[
+            {
+              "name":"govet",
+              "value":"vars"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

tests/configuration/.codacyrc.invalid

@@ -0,0 +1,19 @@
+{
+  "files" : ["foo/bar/baz.go", "foo2/bar/baz.go"],
+  "tools":[
+    {
+      "name":"govet",
+      "patterns":[
+        {
+          "patternId":"govet",
+          "parameters":[
+            {
+              "name":"govet",
+              "value":"vars"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

resources/tests/.codacyrc tests/configuration/.codacyrc.valid

@@ -37,14 +37,14 @@ func newTool(toolDefinition ToolDefinition, config Configuration) Tool {
 	}
 }
 
-func defaultTool() Tool {
-	toolDefinition, err := LoadToolDefinition(defaultDefinitionFile())
+func defaultTool(runConfig RunConfiguration) Tool {
+	toolDefinition, err := LoadToolDefinition(defaultDefinitionFile(runConfig.toolConfigsBasePath))
 	if err != nil {
 		panic(err)
 	}
-	config, err := ParseConfiguration(defaultConfigurationFile())
+	config, err := ParseConfiguration(defaultConfigurationFile(runConfig.toolConfigsBasePath))
 	if err != nil {
-		logrus.Debug(defaultConfigurationFile() + " parsing error: " + err.Error())
+		logrus.Debug(defaultConfigurationFile(runConfig.toolConfigsBasePath) + " parsing error: " + err.Error())
 	}
 
 	return newTool(toolDefinition, config)
@@ -79,10 +79,10 @@ func printResult(issues []Issue) {
 	logrus.Info(printResult)
 }
 
-func startToolImplementation(impl ToolImplementation, sourceDir string) {
-	tool := defaultTool()
+func startToolImplementation(impl ToolImplementation, runConfiguration RunConfiguration) {
+	tool := defaultTool(runConfiguration)
 
-	result, err := impl.Run(tool, sourceDir)
+	result, err := impl.Run(tool, runConfiguration.sourceDir)
 	if err != nil {
 		logrus.Errorln(err.Error())
 		os.Exit(1)

tests/tool/.codacyrc

@@ -5,6 +5,7 @@ import (
 	logrus "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
+	"path/filepath"
 
 	"io/ioutil"
 
@@ -15,14 +16,18 @@ import (
 
 type ToolTestSuite struct {
 	suite.Suite
+	runConfig RunConfiguration
 }
 
 func TestExampleTestSuite(t *testing.T) {
 	suite.Run(t, new(ToolTestSuite))
 }
 
 func (suite *ToolTestSuite) SetupTest() {
-	toolConfigsBasePathFlag = &testsResourcesLocation
+	suite.runConfig = RunConfiguration{
+		toolConfigsBasePath: filepath.Join(testsResourcesLocation, "tool"),
+		sourceDir:           "./",
+	}
 }
 
 func testingTool(name, version string) (ToolDefinition, string) {
@@ -58,7 +63,7 @@ func (suite *ToolTestSuite) TestToolToJSONWithoutVersion() {
 }
 
 func (suite *ToolTestSuite) TestLoadToolDefinition() {
-	patternsFileLocation := defaultDefinitionFile()
+	patternsFileLocation := defaultDefinitionFile(suite.runConfig.toolConfigsBasePath)
 	tool, err := LoadToolDefinition(patternsFileLocation)
 
 	assert.Nil(suite.T(), err, "Failed to load tool %s", patternsFileLocation)
@@ -94,7 +99,7 @@ func (suite *ToolTestSuite) TestPrintResults() {
 }
 
 func (suite *ToolTestSuite) TestDefaultTool() {
-	tool := defaultTool()
+	tool := defaultTool(suite.runConfig)
 
 	patternsLen := len(tool.Patterns)
 	expectedLen := 1
@@ -105,7 +110,7 @@ func (suite *ToolTestSuite) TestDefaultTool() {
 }
 func (suite *ToolTestSuite) TestPatternsFromConfig() {
 	toolName := "govet"
-	configFile := defaultConfigurationFile()
+	configFile := defaultConfigurationFile(suite.runConfig.toolConfigsBasePath)
 	config, err := ParseConfiguration(configFile)
 	assert.Nil(suite.T(), err, "Error parsing config file %s", configFile)
 
@@ -129,12 +134,8 @@ func (i ToolImplementationTest) Run(tool Tool, sourceDir string) ([]Issue, error
 func (suite *ToolTestSuite) TestStartTool() {
 	r, w, oldStdout := setStdoutToBuffer()
 
-	defer func() {
-		logrus.SetOutput(os.Stderr)
-	}()
-
 	impl := ToolImplementationTest{}
-	startToolImplementation(impl, "./")
+	startToolImplementation(impl, suite.runConfig)
 	issue := testIssue()
 
 	out, _ := readStdout(r, w)