test: move "dbservices" tests to Ginkgo style

Requested in PR comment for #983

[#187331719](https://www.pivotaltracker.com/story/show/187331719)

dbservice/dbservice_suite_test.go

@@ -0,0 +1,13 @@
+package dbservice_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestDBService(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "DBService Suite")
+}

dbservice/migrations_test.go

@@ -1,175 +1,84 @@
-// Copyright 2019 the Service Broker Project Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 package dbservice
 
 import (
-	"errors"
 	"math"
 	"os"
-	"reflect"
-	"testing"
 
+	"github.com/cloudfoundry/cloud-service-broker/dbservice/models"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
-
-	"github.com/cloudfoundry/cloud-service-broker/dbservice/models"
 )
 
-func TestValidateLastMigration(t *testing.T) {
-	cases := map[string]struct {
-		LastMigration int
-		Expected      error
-	}{
-		"new-db": {
-			LastMigration: -1,
-			Expected:      nil,
-		},
-		"before-v2": {
-			LastMigration: 0,
-			Expected:      errors.New("migration from broker versions <= 2.0 is no longer supported, upgrade using a v3.x broker then try again"),
-		},
-		"v3-to-v4": {
-			LastMigration: 1,
-			Expected:      nil,
-		},
-		"v4-to-v4.1": {
-			LastMigration: 2,
-			Expected:      nil,
-		},
-		"v4.1-to-v4.2": {
-			LastMigration: 3,
-			Expected:      nil,
-		},
-		"up-to-date": {
-			LastMigration: numMigrations - 1,
-			Expected:      nil,
-		},
-		"future": {
-			LastMigration: numMigrations,
-			Expected:      errors.New("the database you're connected to is newer than this tool supports"),
-		},
-		"far-future": {
-			LastMigration: math.MaxInt32,
-			Expected:      errors.New("the database you're connected to is newer than this tool supports"),
-		},
-	}
-
-	for tn, tc := range cases {
-		t.Run(tn, func(t *testing.T) {
-			actual := ValidateLastMigration(tc.LastMigration)
-
-			if !reflect.DeepEqual(actual, tc.Expected) {
-				t.Errorf("Expected error %v, got %v", tc.Expected, actual)
+var _ = Describe("Migrations", func() {
+	DescribeTable(
+		"validate last migration",
+		func(lastMigration int, expectedError string) {
+			err := ValidateLastMigration(lastMigration)
+			switch expectedError {
+			case "":
+				Expect(err).NotTo(HaveOccurred())
+			default:
+				Expect(err).To(MatchError(expectedError))
 			}
-		})
-	}
-}
-
-func TestRunMigrations_Failures(t *testing.T) {
-	cases := map[string]struct {
-		LastMigration int
-		Expected      error
-	}{
-		"before-v2": {
-			LastMigration: 0,
-			Expected:      errors.New("migration from broker versions <= 2.0 is no longer supported, upgrade using a v3.x broker then try again"),
 		},
-		"future": {
-			LastMigration: numMigrations,
-			Expected:      errors.New("the database you're connected to is newer than this tool supports"),
+		Entry("new-db", -1, nil),
+		Entry("before-v2", 0, "migration from broker versions <= 2.0 is no longer supported, upgrade using a v3.x broker then try again"),
+		Entry("v3-to-v4", 1, nil),
+		Entry("v4-to-v4.1", 2, nil),
+		Entry("v4.1-to-v4.2", 3, nil),
+		Entry("up-to-date", numMigrations-1, nil),
+		Entry("future", numMigrations, "the database you're connected to is newer than this tool supports"),
+		Entry("far-future", math.MaxInt32, "the database you're connected to is newer than this tool supports"),
+	)
+
+	DescribeTable(
+		"RunMigrations() failures",
+		func(lastMigration int, expectedError string) {
+			db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(autoMigrateTables(db, &models.MigrationV1{})).To(Succeed())
+			Expect(db.Save(&models.Migration{MigrationID: lastMigration}).Error).To(Succeed())
+			Expect(RunMigrations(db)).To(MatchError(expectedError))
 		},
-		"far-future": {
-			LastMigration: math.MaxInt32,
-			Expected:      errors.New("the database you're connected to is newer than this tool supports"),
-		},
-	}
-
-	for tn, tc := range cases {
-		t.Run(tn, func(t *testing.T) {
-			db, err := gorm.Open(sqlite.Open("test.sqlite3"), &gorm.Config{})
-			defer func() {
-				_ = os.Remove("test.sqlite3")
-			}()
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			if err := autoMigrateTables(db, &models.MigrationV1{}); err != nil {
-				t.Fatal(err)
-			}
-
-			if err := db.Save(&models.Migration{MigrationID: tc.LastMigration}).Error; err != nil {
-				t.Fatal(err)
-			}
-
-			actual := RunMigrations(db)
-			if !reflect.DeepEqual(actual, tc.Expected) {
-				t.Errorf("Expected error %v, got %v", tc.Expected, actual)
-			}
+		Entry("before-v2", 0, "migration from broker versions <= 2.0 is no longer supported, upgrade using a v3.x broker then try again"),
+		Entry("future", numMigrations, "the database you're connected to is newer than this tool supports"),
+		Entry("far-future", math.MaxInt32, "the database you're connected to is newer than this tool supports"),
+	)
+
+	Describe("RunMigrations() behavior", func() {
+		var db *gorm.DB
+
+		BeforeEach(func() {
+			var err error
+			// The tests don't pass when using an ":memory:" database as opposed to a real file. Presumably a GORM feature.
+			db, err = gorm.Open(sqlite.Open("test.sqlite3"), &gorm.Config{})
+			Expect(err).NotTo(HaveOccurred())
+
+			DeferCleanup(func() {
+				os.Remove("test.sqlite3")
+			})
 		})
-	}
-}
-
-func TestRunMigrations(t *testing.T) {
-	cases := map[string]func(t *testing.T, db *gorm.DB){
-		"creates-migrations-table": func(t *testing.T, db *gorm.DB) {
-			if err := RunMigrations(db); err != nil {
-				t.Fatal(err)
-			}
 
-			if !db.Migrator().HasTable("migrations") {
-				t.Error("Expected db to have migrations table")
-			}
-		},
-
-		"applies-all-migrations-when-run": func(t *testing.T, db *gorm.DB) {
-			if err := RunMigrations(db); err != nil {
-				t.Fatal(err)
-			}
+		It("creates a migration table", func() {
+			Expect(RunMigrations(db)).To(Succeed())
+			Expect(db.Migrator().HasTable("migrations")).To(BeTrue())
+		})
 
+		It("applies all migrations when run", func() {
+			Expect(RunMigrations(db)).To(Succeed())
 			var storedMigrations []models.Migration
-			if err := db.Order("id desc").Find(&storedMigrations).Error; err != nil {
-				t.Fatal(err)
-			}
-
+			Expect(db.Order("id desc").Find(&storedMigrations).Error).To(Succeed())
 			lastMigrationNumber := storedMigrations[0].MigrationID
-			if lastMigrationNumber != numMigrations-1 {
-				t.Errorf("expected lastMigrationNumber to be %d, got %d", numMigrations-1, lastMigrationNumber)
-			}
-		},
-
-		"can-run-migrations-multiple-times": func(t *testing.T, db *gorm.DB) {
-			for i := 0; i < 10; i++ {
-				if err := RunMigrations(db); err != nil {
-					t.Fatal(err)
-				}
-			}
-		},
-	}
+			Expect(lastMigrationNumber).To(Equal(numMigrations - 1))
+		})
 
-	for tn, tc := range cases {
-		t.Run(tn, func(t *testing.T) {
-			db, err := gorm.Open(sqlite.Open("test.sqlite3"), &gorm.Config{})
-			defer func() {
-				_ = os.Remove("test.sqlite3")
-			}()
-			if err != nil {
-				t.Fatal(err)
+		It("can run migrations multiple times", func() {
+			for range 10 {
+				Expect(RunMigrations(db)).To(Succeed())
 			}
-
-			tc(t, db)
 		})
-	}
-}
+	})
+})

dbservice/recover_in_progress_operations_test.go

@@ -1,83 +1,60 @@
 package dbservice
 
 import (
-	"strings"
-	"testing"
-
 	"code.cloudfoundry.org/lager/v3/lagertest"
 	"github.com/cloudfoundry/cloud-service-broker/dbservice/models"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 )
 
-func TestRecoverInProgressOperations(t *testing.T) {
-	// Setup
-	db, err := gorm.Open(sqlite.Open(":memory:"), nil)
-	if err != nil {
-		t.Errorf("failed to create test database: %s", err)
-	}
-
-	if err = db.Migrator().CreateTable(&models.TerraformDeployment{}); err != nil {
-		t.Errorf("failed to create test table: %s", err)
-	}
-
-	const recoverID = "fake-id-to-recover"
-	err = db.Create(&models.TerraformDeployment{
-		ID:                   recoverID,
-		LastOperationType:    "fake-type",
-		LastOperationState:   "in progress",
-		LastOperationMessage: "fake-type in progress",
-	}).Error
-	if err != nil {
-		t.Errorf("failed to create test database data: %s", err)
-	}
-	const okID = "fake-id-that-does-not-need-to-be-recovered"
-	err = db.Create(&models.TerraformDeployment{
-		ID:                   okID,
-		LastOperationType:    "fake-type",
-		LastOperationState:   "succeeded",
-		LastOperationMessage: "fake-type succeeded",
-	}).Error
-	if err != nil {
-		t.Errorf("failed to create test database data: %s", err)
-	}
-
-	// Call the function
-	logger := lagertest.NewTestLogger("test")
-	recoverInProgressOperations(db, logger)
-
-	// It marks the in-progress operation as failed
-	var r1 models.TerraformDeployment
-	err = db.Where("id = ?", recoverID).First(&r1).Error
-	if err != nil {
-		t.Errorf("failed to load updated test data: %s", err)
-	}
-
-	const expState = "failed"
-	if r1.LastOperationState != expState {
-		t.Errorf("LastOperationState, expected %q, got %q", expState, r1.LastOperationState)
-	}
-
-	const expMessage = "the broker restarted while the operation was in progress"
-	if r1.LastOperationMessage != expMessage {
-		t.Errorf("LastOperationMessage, expected %q, got %q", expMessage, r1.LastOperationMessage)
-	}
-
-	// It does not update other operations
-	var r2 models.TerraformDeployment
-	err = db.Where("id = ?", okID).First(&r2).Error
-	if err != nil {
-		t.Errorf("failed to load updated test data: %s", err)
-	}
-	if r2.LastOperationState != "succeeded" || r2.LastOperationMessage != "fake-type succeeded" {
-		t.Error("row corruption")
-	}
-
-	// It logs the expected message
-	const expLog1 = `"message":"test.recover-in-progress-operations.mark-as-failed"`
-	const expLog2 = `"workspace_id":"fake-id-to-recover"`
-	logMessage := string(logger.Buffer().Contents())
-	if !strings.Contains(logMessage, expLog1) || !strings.Contains(logMessage, expLog2) {
-		t.Errorf("log, expected to contain %q and %q, got %q", expLog1, expLog2, logMessage)
-	}
-}
+var _ = Describe("RecoverInProgressOperations()", func() {
+	It("recovers the expected operations", func() {
+		const (
+			recoverID = "fake-id-to-recover"
+			okID      = "fake-id-that-does-not-need-to-be-recovered"
+		)
+
+		// Setup
+		db, err := gorm.Open(sqlite.Open(":memory:"), nil)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(db.Migrator().CreateTable(&models.TerraformDeployment{})).To(Succeed())
+
+		Expect(db.Create(&models.TerraformDeployment{
+			ID:                   recoverID,
+			LastOperationType:    "fake-type",
+			LastOperationState:   "in progress",
+			LastOperationMessage: "fake-type in progress",
+		}).Error).To(Succeed())
+		Expect(db.Create(&models.TerraformDeployment{
+			ID:                   okID,
+			LastOperationType:    "fake-type",
+			LastOperationState:   "succeeded",
+			LastOperationMessage: "fake-type succeeded",
+		}).Error).To(Succeed())
+
+		// Call the function
+		logger := lagertest.NewTestLogger("test")
+		recoverInProgressOperations(db, logger)
+
+		// Behaviors
+		By("marking the in-progress operation as failed")
+		var r1 models.TerraformDeployment
+		Expect(db.Where("id = ?", recoverID).First(&r1).Error).To(Succeed())
+		Expect(r1.LastOperationState).To(Equal("failed"))
+		Expect(r1.LastOperationMessage).To(Equal("the broker restarted while the operation was in progress"))
+
+		By("no updating other operations")
+		var r2 models.TerraformDeployment
+		Expect(db.Where("id = ?", okID).First(&r2).Error).To(Succeed())
+		Expect(r2.LastOperationState).To(Equal("succeeded"))
+		Expect(r2.LastOperationMessage).To(Equal("fake-type succeeded"))
+
+		By("logging the expected message")
+		Expect(logger.Buffer().Contents()).To(SatisfyAll(
+			ContainSubstring(`"message":"test.recover-in-progress-operations.mark-as-failed"`),
+			ContainSubstring(`"workspace_id":"fake-id-to-recover"`),
+		))
+	})
+})