Merge lp:~elopio/snappy/lint_and_vet_tests into lp:~snappy-dev/snappy/snappy-moved-to-github

[Leo Arias]

Added lint and vet checks for the integration tests.
Fixed the existing errors.

[Sergio Schvezov (sergiusens)]

nice

review: Approve

=== modified file '_integration-tests/tests/common/common.go'
--- _integration-tests/tests/common/common.go	2015-06-29 16:04:21 +0000
+++ _integration-tests/tests/common/common.go	2015-06-30 17:01:39 +0000
@@ -29,100 +29,156 @@
 	"strconv"
 	"strings"
 
-	. "gopkg.in/check.v1"
+	check "gopkg.in/check.v1"
 )
 
 const (
 	needsRebootFile = "/tmp/needs-reboot"
 )
 
-type CommonSuite struct{}
-
-func ExecCommand(c *C, cmds ...string) string {
+// SnappySuite is a structure used as a base test suite for all the snappy
+// integration tests.
+type SnappySuite struct{}
+
+// SetUpSuite disables the snappy autopilot. It will run before all the
+// integration suites.
+func (s *SnappySuite) SetUpSuite(c *check.C) {
+	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+}
+
+// SetUpTest handles reboots and stores version information. It will run before
+// all the integration tests. Before running a test, it will save the
+// ubuntu-core version. If a reboot was requested by a previous test, it
+// will skip all the following tests. If the suite is being called after the
+// test bed was rebooted, it will resume the test that requested the reboot.
+func (s *SnappySuite) SetUpTest(c *check.C) {
+	if needsReboot() {
+		contents, err := ioutil.ReadFile(needsRebootFile)
+		c.Assert(err, check.IsNil, check.Commentf("Error reading needs-reboot file %v", err))
+		c.Skip(fmt.Sprintf("****** Skipped %s during reboot caused by %s",
+			c.TestName(), contents))
+	} else {
+
+		afterReboot := os.Getenv("ADT_REBOOT_MARK")
+
+		if afterReboot == "" {
+			c.Logf("****** Running %s", c.TestName())
+			SetSavedVersion(c, GetCurrentVersion(c))
+		} else {
+			if afterReboot == c.TestName() {
+				c.Logf("****** Resuming %s after reboot", c.TestName())
+			} else {
+				c.Skip(fmt.Sprintf("****** Skipped %s after reboot caused by %s",
+					c.TestName(), afterReboot))
+			}
+		}
+	}
+}
+
+// ExecCommand executes a shell command and returns a string with the output
+// of the command. In case of error, it will fail the test.
+func ExecCommand(c *check.C, cmds ...string) string {
 	fmt.Println(strings.Join(cmds, " "))
 	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
 	output, err := cmd.CombinedOutput()
 	stringOutput := string(output)
-	c.Assert(err, IsNil, Commentf("Error: %v", stringOutput))
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", stringOutput))
 	return stringOutput
 }
 
-func ExecCommandToFile(c *C, filename string, cmds ...string) {
+// ExecCommandToFile executes a shell command and saves the output of the
+// command to a file. In case of error, it will fail the test.
+func ExecCommandToFile(c *check.C, filename string, cmds ...string) {
 	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
 	outfile, err := os.Create(filename)
-	c.Assert(err, IsNil, Commentf("Error creating output file %s", filename))
+	c.Assert(err, check.IsNil, check.Commentf("Error creating output file %s", filename))
 
 	defer outfile.Close()
 	cmd.Stdout = outfile
 
 	err = cmd.Run()
-	c.Assert(err, IsNil, Commentf("Error executing command '%v': %v", cmds, err))
+	c.Assert(err, check.IsNil, check.Commentf("Error executing command '%v': %v", cmds, err))
 }
 
-func GetCurrentVersion(c *C) int {
+// GetCurrentVersion returns the version number of the installed and active
+// ubuntu-core.
+func GetCurrentVersion(c *check.C) int {
 	output := ExecCommand(c, "snappy", "list")
 	pattern := "(?mU)^ubuntu-core (.*)$"
 	re := regexp.MustCompile(pattern)
 	match := re.FindStringSubmatch(string(output))
-	c.Assert(match, NotNil, Commentf("Version not found in %s", output))
+	c.Assert(match, check.NotNil, check.Commentf("Version not found in %s", output))
 
 	// match is like "ubuntu-core   2015-06-18 93        ubuntu"
 	items := strings.Fields(match[0])
 	version, err := strconv.Atoi(items[2])
-	c.Assert(err, IsNil, Commentf("Error converting version to int %v", version))
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version to int %v", version))
 	return version
 }
 
-func CallUpdate(c *C) {
+// CallUpdate executes an snappy update.
+func CallUpdate(c *check.C) {
 	c.Log("Calling snappy update...")
 	ExecCommand(c, "sudo", "snappy", "update")
 }
 
-func Reboot(c *C) {
+// Reboot requests a reboot using the test name as the mark.
+func Reboot(c *check.C) {
 	RebootWithMark(c, c.TestName())
 }
 
-func RebootWithMark(c *C, mark string) {
+// RebootWithMark requests a reboot using a specified mark.
+func RebootWithMark(c *check.C, mark string) {
 	c.Log("Preparing reboot with mark " + mark)
 	err := ioutil.WriteFile(needsRebootFile, []byte(mark), 0777)
-	c.Assert(err, IsNil, Commentf("Error writing needs-reboot file: %v", err))
+	c.Assert(err, check.IsNil, check.Commentf("Error writing needs-reboot file: %v", err))
 }
 
-func needsReboot(c *C) bool {
+func needsReboot() bool {
 	_, err := os.Stat(needsRebootFile)
 	return err == nil
 }
 
-func BeforeReboot(c *C) bool {
-	return checkRebootMark(c, "")
+// BeforeReboot returns True if the test is running before the test bed has
+// been rebooted, or after the test that requested the reboot handled it.
+func BeforeReboot() bool {
+	return checkRebootMark("")
 }
 
-func AfterReboot(c *C) bool {
+// AfterReboot returns True if the test is running after the test bed has been
+// rebooted.
+func AfterReboot(c *check.C) bool {
 	// $ADT_REBOOT_MARK contains the reboot mark, if we have rebooted it'll be the test name
-	return checkRebootMark(c, c.TestName())
+	return checkRebootMark(c.TestName())
 }
 
-func checkRebootMark(c *C, mark string) bool {
+func checkRebootMark(mark string) bool {
 	return os.Getenv("ADT_REBOOT_MARK") == mark
 }
 
-func RemoveRebootMark(c *C) {
+// RemoveRebootMark removes the reboot mark to signal that the reboot has been
+// handled.
+func RemoveRebootMark(c *check.C) {
 	os.Setenv("ADT_REBOOT_MARK", "")
 }
 
-func SetSavedVersion(c *C, version int) {
+// SetSavedVersion saves a version number into a file so it can be used on
+// tests after reboots.
+func SetSavedVersion(c *check.C, version int) {
 	versionFile := getVersionFile()
 	err := ioutil.WriteFile(versionFile, []byte(strconv.Itoa(version)), 0777)
-	c.Assert(err, IsNil, Commentf("Error writing version file %s with %s", versionFile, version))
+	c.Assert(err, check.IsNil, check.Commentf("Error writing version file %s with %s", versionFile, version))
 }
 
-func GetSavedVersion(c *C) int {
+// GetSavedVersion returns the saved version number.
+func GetSavedVersion(c *check.C) int {
 	versionFile := getVersionFile()
 	contents, err := ioutil.ReadFile(versionFile)
-	c.Assert(err, IsNil, Commentf("Error reading version file %s", versionFile))
+	c.Assert(err, check.IsNil, check.Commentf("Error reading version file %s", versionFile))
 
 	version, err := strconv.Atoi(string(contents))
-	c.Assert(err, IsNil, Commentf("Error converting version %v", contents))
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version %v", contents))
 
 	return version
 }
@@ -130,32 +186,3 @@
 func getVersionFile() string {
 	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "version")
 }
-
-func (s *CommonSuite) SetUpSuite(c *C) {
-	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
-	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
-}
-
-func (s *CommonSuite) SetUpTest(c *C) {
-	if needsReboot(c) {
-		contents, err := ioutil.ReadFile(needsRebootFile)
-		c.Assert(err, IsNil, Commentf("Error reading needs-reboot file %v", err))
-		c.Skip(fmt.Sprintf("****** Skipped %s during reboot caused by %s",
-			c.TestName(), contents))
-	} else {
-
-		afterReboot := os.Getenv("ADT_REBOOT_MARK")
-
-		if afterReboot == "" {
-			c.Logf("****** Running %s", c.TestName())
-			SetSavedVersion(c, GetCurrentVersion(c))
-		} else {
-			if afterReboot == c.TestName() {
-				c.Logf("****** Resuming %s after reboot", c.TestName())
-			} else {
-				c.Skip(fmt.Sprintf("****** Skipped %s after reboot caused by %s",
-					c.TestName(), afterReboot))
-			}
-		}
-	}
-}
 
=== modified file '_integration-tests/tests/failover/failover_test.go'
--- _integration-tests/tests/failover/failover_test.go	2015-06-29 16:06:12 +0000
+++ _integration-tests/tests/failover/failover_test.go	2015-06-30 17:01:39 +0000
@@ -36,7 +36,7 @@
 var _ = Suite(&failoverSuite{})
 
 type failoverSuite struct {
-	CommonSuite
+	SnappySuite
 }
 
 const (
 
=== modified file '_integration-tests/tests/latest/install_test.go'
--- _integration-tests/tests/latest/install_test.go	2015-06-30 15:02:22 +0000
+++ _integration-tests/tests/latest/install_test.go	2015-06-30 17:01:39 +0000
@@ -34,7 +34,7 @@
 var _ = Suite(&installSuite{})
 
 type installSuite struct {
-	CommonSuite
+	SnappySuite
 }
 
 func installSnap(c *C, packageName string) string {
 
=== modified file '_integration-tests/tests/update/update_test.go'
--- _integration-tests/tests/update/update_test.go	2015-06-24 17:19:58 +0000
+++ _integration-tests/tests/update/update_test.go	2015-06-30 17:01:39 +0000
@@ -33,7 +33,7 @@
 var _ = Suite(&updateSuite{})
 
 type updateSuite struct {
-	CommonSuite
+	SnappySuite
 }
 
 func rollback(c *C) {
@@ -46,7 +46,7 @@
 }
 
 func (s *updateSuite) TestUpdateMustInstallNewerVersion(c *C) {
-	if BeforeReboot(c) {
+	if BeforeReboot() {
 		CallUpdate(c)
 		Reboot(c)
 	} else if AfterReboot(c) {
 
=== modified file 'run-checks'
--- run-checks	2015-06-29 23:15:00 +0000
+++ run-checks	2015-06-30 17:01:39 +0000
@@ -45,10 +45,11 @@
 # go vet
 echo Running vet
 go vet ./...
+go vet ./_integration-tests/tests/...
 
 # golint
 echo Running lint
-lint=$(golint ./...)
+lint=$(golint ./... && golint ./_integration-tests/tests/...)
 if [ -n "$lint" ]; then
     echo "Lint complains:"
     echo $lint