Overhaul database package

go/buildbot/buildbot_test.go

 package buildbot
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io"
         "net/http"
         "path/filepath"
         "reflect"
         "testing"
 
         "github.com/golang/glog"
 
-        "skia.googlesource.com/buildbot.git/go/database"
+        "skia.googlesource.com/buildbot.git/go/database/testutil"
         "skia.googlesource.com/buildbot.git/go/gitinfo"
         "skia.googlesource.com/buildbot.git/go/testutils"
         "skia.googlesource.com/buildbot.git/go/util"
 )
 
 var (
         // testJsonInput is raw JSON data as returned from the build master.
         testJsonInput = testutils.MustReadFile("default_build.json")
 
         // testIncompleteBuild is JSON data for a not-yet-finished build.
@@ skipping 21 matching lines @@
                 "http://build.chromium.org/p/client.skia/json/builders/Test-Ubuntu12-ShuttleA-GTX660-x86-Release/builds/721":               []byte(testJsonInput),
                 "http://build.chromium.org/p/client.skia/json/builders/Test-Ubuntu12-ShuttleA-GTX550Ti-x86_64-Release-Valgrind/builds/152": []byte(testIncompleteBuild),
                 "http://build.chromium.org/p/client.skia.android/json/builders/Perf-Android-Venue8-PowerVR-x86-Release/builds/464":         []byte(venue464),
                 "http://build.chromium.org/p/client.skia.android/json/builders/Perf-Android-Venue8-PowerVR-x86-Release/builds/465":         []byte(venue465),
                 "http://build.chromium.org/p/client.skia.android/json/builders/Perf-Android-Venue8-PowerVR-x86-Release/builds/466":         []byte(venue466),
                 "http://build.chromium.org/p/client.skia.fyi/json/builders/Housekeeper-PerCommit/builds/1035":                              []byte(housekeeper1035),
         }
 )
 
 // clearDB initializes the database, upgrading it if needed, and removes all
-// data to ensure that the test begins with a clean slate.
-func clearDB(t *testing.T, conf *database.DatabaseConfig) error {
+// data to ensure that the test begins with a clean slate. Returns a MySQLTestDatabase
+// which must be closed after the test finishes.
+func clearDB(t *testing.T) *testutil.MySQLTestDatabase {
         failMsg := "Database initialization failed. Do you have the test database set up properly?  Details: %v"
-        if err := InitDB(conf); err != nil {
+
+        // Set up the database.
+        testDb := testutil.SetupMySQLTestDatabase(t, migrationSteps)
+
+        if err := InitDB(true); err != nil {
                 t.Fatalf(failMsg, err)
         }
-        tables := []string{
-                TABLE_BUILD_REVISIONS,
-                TABLE_BUILD_STEPS,
-                TABLE_BUILDS,
-        }
-        // Delete the data.
-        for _, table := range tables {
-                _, err := DB.Exec(fmt.Sprintf("DELETE FROM %s;", table))
-                if err != nil {
-                        t.Fatalf(failMsg, err)
-                }
-        }
-        return nil
+
+        return testDb
 }
 
 // respBodyCloser is a wrapper which lets us pretend to implement io.ReadCloser
 // by wrapping a bytes.Reader.
 type respBodyCloser struct {
         io.Reader
 }
 
 // Close is a stub method which lets us pretend to implement io.ReadCloser.
 func (r respBodyCloser) Close() error {
@@ skipping 14 matching lines @@
 // testGetBuild is a helper function which pretends to load JSON data from a
 // build master and decodes it into a Build object.
 func testGetBuildFromMaster(repo *gitinfo.GitInfo) (*Build, error) {
         httpGet = testGet
         return getBuildFromMaster("client.skia", "Test-Ubuntu12-ShuttleA-GTX660-x86-Release", 721, repo)
 }
 
 // TestGetBuildFromMaster verifies that we can load JSON data from the build master and
 // decode it into a Build object.
 func TestGetBuildFromMaster(t *testing.T) {
-        clearDB(t, ProdDatabaseConfig(true))
+        d := clearDB(t)
+        defer d.Close()
 
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // Default, complete build.
         if _, err := testGetBuildFromMaster(repo); err != nil {
                 t.Fatal(err)
         }
         // Incomplete build.
         _, err = getBuildFromMaster("client.skia", "Test-Ubuntu12-ShuttleA-GTX550Ti-x86_64-Release-Valgrind", 152, repo)
         if err != nil {
                 t.Fatal(err)
         }
 }
 
 // TestBuildJsonSerialization verifies that we can serialize a build to JSON
 // and back without losing or corrupting the data.
 func TestBuildJsonSerialization(t *testing.T) {
-        if err := clearDB(t, ProdDatabaseConfig(true)); err != nil {
-                t.Fatal(err)
-        }
+        d := clearDB(t)
+        defer d.Close()
 
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         b1, err := testGetBuildFromMaster(repo)
         if err != nil {
                 t.Fatal(err)
         }
         bytes, err := json.Marshal(b1)
         if err != nil {
                 t.Fatal(err)
         }
         b2 := &Build{}
         if err := json.Unmarshal(bytes, b2); err != nil {
                 t.Fatal(err)
         }
         if !reflect.DeepEqual(b1, b2) {
                 t.Fatalf("Serialization diff:\nIn:  %v\nOut: %v", b1, b2)
         }
 }
 
 // TestFindCommitsForBuild verifies that findCommitsForBuild correctly obtains
 // the list of commits which were newly built in a given build.
 func TestFindCommitsForBuild(t *testing.T) {
-        if err := clearDB(t, ProdDatabaseConfig(true)); err != nil {
-                t.Fatal(err)
-        }
+        d := clearDB(t)
+        defer d.Close()
 
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // The test repo is laid out like this:
@@ skipping 97 matching lines @@
                                 glog.Errorf("Not equal:\n %+v\n %+v\n", s, b2.Steps[i])
                         }
                 }
                 return fmt.Errorf("Builds are not equal! Builds:\nExpected: %+v\nActual:   %+v", b1, b2)
         }
         return nil
 }
 
 // testBuildDbSerialization verifies that we can write a build to the DB and
 // pull it back out without losing or corrupting the data.
-func testBuildDbSerialization(t *testing.T, conf *database.DatabaseConfig) {
-        clearDB(t, conf)
+func testBuildDbSerialization(t *testing.T) {
+        d := clearDB(t)
+        defer d.Close()
+
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // Test case: an empty build. Tests null and empty values.
         emptyTime := 0.0
@@ skipping 13 matching lines @@
         for _, b := range testCases {
                 if err = dbSerializeAndCompare(b); err != nil {
                         t.Fatal(err)
                 }
         }
 }
 
 // testUnfinishedBuild verifies that we can write a build which is not yet
 // finished, load the build back from the database, and update it when it
 // finishes.
-func testUnfinishedBuild(t *testing.T, conf *database.DatabaseConfig) {
-        clearDB(t, conf)
+func testUnfinishedBuild(t *testing.T) {
+        d := clearDB(t)
+        defer d.Close()
+
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // Obtain and insert an unfinished build.
         httpGet = testGet
@@ skipping 61 matching lines @@
                         break
                 }
         }
         if found {
                 t.Fatal(fmt.Errorf("Finished build was found by getUnfinishedBuilds!"))
         }
 }
 
 // testLastProcessedBuilds verifies that getLastProcessedBuilds gives us
 // the expected result.
-func testLastProcessedBuilds(t *testing.T, conf *database.DatabaseConfig) {
-        clearDB(t, conf)
+func testLastProcessedBuilds(t *testing.T) {
+        d := clearDB(t)
+        defer d.Close()
+
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         build, err := testGetBuildFromMaster(repo)
         if err != nil {
@@ skipping 99 matching lines @@
         actual, err := getLatestBuilds()
         if err != nil {
                 t.Fatal(err)
         }
         if !reflect.DeepEqual(expected, actual) {
                 t.Fatal(fmt.Errorf("getLatestBuilds returned incorrect results: %v", actual))
         }
 }
 
 // testGetUningestedBuilds verifies that getUningestedBuilds works as expected.
-func testGetUningestedBuilds(t *testing.T, conf *database.DatabaseConfig) {
-        // First, insert some builds into the database as a starting point.
-        clearDB(t, conf)
+func testGetUningestedBuilds(t *testing.T) {
+        d := clearDB(t)
+        defer d.Close()
 
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // This builder is no longer found on the master.
@@ skipping 68 matching lines @@
                 t.Fatal(err)
         }
         if !reflect.DeepEqual(expected, actual) {
                 t.Fatal(fmt.Errorf("getUningestedBuilds returned incorrect results: %v", actual))
         }
 }
 
 // testIngestNewBuilds verifies that we can successfully query the masters and
 // the database for new and unfinished builds, respectively, and ingest them
 // into the database.
-func testIngestNewBuilds(t *testing.T, conf *database.DatabaseConfig) {
-        // First, insert some builds into the database as a starting point.
-        clearDB(t, conf)
+func testIngestNewBuilds(t *testing.T) {
+        d := clearDB(t)
+        defer d.Close()
 
         // Load the test repo.
         tr := util.NewTempRepo()
         defer tr.Cleanup()
         repo, err := gitinfo.NewGitInfo(filepath.Join(tr.Dir, "testrepo"), false, true)
         if err != nil {
                 t.Fatal(err)
         }
 
         // This builder needs to load a few builds.
@@ skipping 82 matching lines @@
                 }
                 if !(a.MasterName == e.MasterName && a.BuilderName == e.BuilderName && a.Number == e.Number) {
                         t.Fatalf("Incorrect build was inserted! %v", a)
                 }
                 if !a.IsFinished() {
                         t.Fatalf("Failed to update build properly; it should be finished: %v", a)
                 }
         }
 }
 
-func TestSQLiteBuildDbSerialization(t *testing.T) {
-        testBuildDbSerialization(t, ProdDatabaseConfig(true))
-}
-
-func TestSQLiteUnfinishedBuild(t *testing.T) {
-        testUnfinishedBuild(t, ProdDatabaseConfig(true))
-}
-
-func TestSQLiteLastProcessedBuilds(t *testing.T) {
-        testLastProcessedBuilds(t, ProdDatabaseConfig(true))
-}
-
-func TestSQLiteGetUningestedBuilds(t *testing.T) {
-        testGetUningestedBuilds(t, ProdDatabaseConfig(true))
-}
-
-func TestSQLiteIngestNewBuilds(t *testing.T) {
-        testIngestNewBuilds(t, ProdDatabaseConfig(true))
-}
-
-// The below MySQL tests require:
-// shell> mysql -u root
-// mysql> CREATE DATABASE sk_testing;
-// mysql> CREATE USER 'test_user'@'localhost';
-// mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP ON sk_testing.* TO 'test_user'@'localhost';
-//
-// They are skipped when using the -short flag.
 func TestMySQLBuildDbSerialization(t *testing.T) {
         if testing.Short() {
                 t.Skip("Skipping MySQL tests with -short.")
         }
-        testBuildDbSerialization(t, localMySQLTestDatabaseConfig("test_user", ""))
+        testBuildDbSerialization(t)
 }
 
 func TestMySQLUnfinishedBuild(t *testing.T) {
         if testing.Short() {
                 t.Skip("Skipping MySQL tests with -short.")
         }
-        testUnfinishedBuild(t, localMySQLTestDatabaseConfig("test_user", ""))
+        testUnfinishedBuild(t)
 }
 
 func TestMySQLLastProcessedBuilds(t *testing.T) {
         if testing.Short() {
                 t.Skip("Skipping MySQL tests with -short.")
         }
-        testLastProcessedBuilds(t, localMySQLTestDatabaseConfig("test_user", ""))
+        testLastProcessedBuilds(t)
 }
 
 func TestMySQLGetUningestedBuilds(t *testing.T) {
         if testing.Short() {
                 t.Skip("Skipping MySQL tests with -short.")
         }
-        testGetUningestedBuilds(t, localMySQLTestDatabaseConfig("test_user", ""))
+        testGetUningestedBuilds(t)
 }
 
 func TestMySQLIngestNewBuilds(t *testing.T) {
         if testing.Short() {
                 t.Skip("Skipping MySQL tests with -short.")
         }
-        testIngestNewBuilds(t, localMySQLTestDatabaseConfig("test_user", ""))
+        testIngestNewBuilds(t)
 }