feat(database): add agnostic engine

database/close.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
+//
+// Use of this source code is governed by the LICENSE file in this repository.
+
+package database
+
+// Close stops and terminates the connection to the database.
+func (e *engine) Close() error {
+	e.Logger.Tracef("closing connection to the %s database", e.Driver())
+
+	// capture database/sql database from gorm.io/gorm database
+	_sql, err := e.Database.DB()
+	if err != nil {
+		return err
+	}
+
+	return _sql.Close()
+}

database/close_test.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
+//
+// Use of this source code is governed by the LICENSE file in this repository.
+
+package database
+
+import (
+	"testing"
+
+	"github.com/sirupsen/logrus"
+
+	"gorm.io/gorm"
+)
+
+func TestDatabase_Engine_Close(t *testing.T) {
+	_postgres, _mock := testPostgres(t)
+	defer _postgres.Close()
+	// ensure the mock expects the close
+	_mock.ExpectClose()
+
+	// create a test database without mocking the call
+	_unmocked, _ := testPostgres(t)
+
+	_sqlite := testSqlite(t)
+	defer _sqlite.Close()
+
+	// setup tests
+	tests := []struct {
+		failure  bool
+		name     string
+		database *engine
+	}{
+		{
+			name:     "success with postgres",
+			failure:  false,
+			database: _postgres,
+		},
+		{
+			name:     "success with sqlite3",
+			failure:  false,
+			database: _sqlite,
+		},
+		{
+			name:     "failure without mocked call",
+			failure:  true,
+			database: _unmocked,
+		},
+		{
+			name:    "failure with invalid gorm database",
+			failure: true,
+			database: &engine{
+				Config: &Config{
+					Driver: "invalid",
+				},
+				Database: &gorm.DB{
+					Config: &gorm.Config{
+						ConnPool: nil,
+					},
+				},
+				Logger: logrus.NewEntry(logrus.StandardLogger()),
+			},
+		},
+	}
+
+	// run tests
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.database.Close()
+
+			if test.failure {
+				if err == nil {
+					t.Errorf("Close for %s should have returned err", test.name)
+				}
+
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Close for %s returned err: %v", test.name, err)
+			}
+		})
+	}
+}

database/database.go

@@ -1,15 +1,69 @@
-// Copyright (c) 2022 Target Brands, Inc. All rights reserved.
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
 //
 // Use of this source code is governed by the LICENSE file in this repository.
 
 package database
 
 import (
 	"fmt"
+	"time"
 
+	"github.com/go-vela/server/database/build"
+	"github.com/go-vela/server/database/hook"
+	"github.com/go-vela/server/database/log"
+	"github.com/go-vela/server/database/pipeline"
+	"github.com/go-vela/server/database/repo"
+	"github.com/go-vela/server/database/schedule"
+	"github.com/go-vela/server/database/secret"
+	"github.com/go-vela/server/database/service"
+	"github.com/go-vela/server/database/step"
+	"github.com/go-vela/server/database/user"
+	"github.com/go-vela/server/database/worker"
 	"github.com/go-vela/types/constants"
-
 	"github.com/sirupsen/logrus"
+
+	"gorm.io/gorm"
+)
+
+type (
+	// Config represents the settings required to create the engine that implements the Interface.
+	Config struct {
+		// specifies the address to use for the database engine
+		Address string
+		// specifies the level of compression to use for the database engine
+		CompressionLevel int
+		// specifies the maximum idle connections for the database engine
+		ConnectionIdle int
+		// specifies the connection duration to use for the database engine
+		ConnectionLife time.Duration
+		// specifies the maximum open connections for the database engine
+		ConnectionOpen int
+		// specifies the driver to use for the database engine
+		Driver string
+		// specifies the encryption key to use for the database engine
+		EncryptionKey string
+		// specifies to skip creating tables and indexes for the database engine
+		SkipCreation bool
+	}
+
+	// engine represents the functionality that implements the Interface.
+	engine struct {
+		Config   *Config
+		Database *gorm.DB
+		Logger   *logrus.Entry
+
+		build.BuildInterface
+		hook.HookInterface
+		log.LogInterface
+		pipeline.PipelineInterface
+		repo.RepoInterface
+		schedule.ScheduleInterface
+		secret.SecretInterface
+		service.ServiceInterface
+		step.StepInterface
+		user.UserInterface
+		worker.WorkerInterface
+	}
 )
 
 // New creates and returns a Vela service capable of

database/database_test.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Target Brands, Inc. All rights reserved.
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
 //
 // Use of this source code is governed by the LICENSE file in this repository.
 
@@ -7,6 +7,13 @@ package database
 import (
 	"testing"
 	"time"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/sirupsen/logrus"
+
+	"gorm.io/driver/postgres"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
 )
 
 func TestDatabase_New(t *testing.T) {
@@ -86,3 +93,73 @@ func TestDatabase_New(t *testing.T) {
 		}
 	}
 }
+
+// testPostgres is a helper function to create a Postgres engine for testing.
+func testPostgres(t *testing.T) (*engine, sqlmock.Sqlmock) {
+	// create the engine with test configuration
+	_engine := &engine{
+		Config: &Config{
+			CompressionLevel: 3,
+			ConnectionLife:   30 * time.Minute,
+			ConnectionIdle:   2,
+			ConnectionOpen:   0,
+			Driver:           "postgres",
+			EncryptionKey:    "A1B2C3D4E5G6H7I8J9K0LMNOPQRSTUVW",
+			SkipCreation:     false,
+		},
+		Logger: logrus.NewEntry(logrus.StandardLogger()),
+	}
+
+	// create the new mock sql database
+	_sql, _mock, err := sqlmock.New(
+		sqlmock.MonitorPingsOption(true),
+		sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual),
+	)
+	if err != nil {
+		t.Errorf("unable to create new SQL mock: %v", err)
+	}
+	// ensure the mock expects the ping
+	_mock.ExpectPing()
+
+	// create the new mock Postgres database client
+	_engine.Database, err = gorm.Open(
+		postgres.New(postgres.Config{Conn: _sql}),
+		&gorm.Config{SkipDefaultTransaction: true},
+	)
+	if err != nil {
+		t.Errorf("unable to create new test postgres database: %v", err)
+	}
+
+	return _engine, _mock
+}
+
+// testSqlite is a helper function to create a Sqlite engine for testing.
+func testSqlite(t *testing.T) *engine {
+	var err error
+
+	// create the engine with test configuration
+	_engine := &engine{
+		Config: &Config{
+			Address:          "file::memory:?cache=shared",
+			CompressionLevel: 3,
+			ConnectionLife:   30 * time.Minute,
+			ConnectionIdle:   2,
+			ConnectionOpen:   0,
+			Driver:           "sqlite3",
+			EncryptionKey:    "A1B2C3D4E5G6H7I8J9K0LMNOPQRSTUVW",
+			SkipCreation:     false,
+		},
+		Logger: logrus.NewEntry(logrus.StandardLogger()),
+	}
+
+	// create the new mock Sqlite database client
+	_engine.Database, err = gorm.Open(
+		sqlite.Open(_engine.Config.Address),
+		&gorm.Config{SkipDefaultTransaction: true},
+	)
+	if err != nil {
+		t.Errorf("unable to create new test sqlite database: %v", err)
+	}
+
+	return _engine
+}

database/driver.go

@@ -0,0 +1,10 @@
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
+//
+// Use of this source code is governed by the LICENSE file in this repository.
+
+package database
+
+// Driver outputs the configured database driver.
+func (e *engine) Driver() string {
+	return e.Config.Driver
+}

database/driver_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 Target Brands, Inc. All rights reserved.
+//
+// Use of this source code is governed by the LICENSE file in this repository.
+
+package database
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDatabase_Engine_Driver(t *testing.T) {
+	_postgres, _ := testPostgres(t)
+	defer _postgres.Close()
+
+	_sqlite := testSqlite(t)
+	defer _sqlite.Close()
+
+	// setup tests
+	tests := []struct {
+		name     string
+		database *engine
+		want     string
+	}{
+		{
+			name:     "success with postgres",
+			database: _postgres,
+			want:     "postgres",
+		},
+		{
+			name:     "success with sqlite3",
+			database: _sqlite,
+			want:     "sqlite3",
+		},
+	}
+
+	// run tests
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got := test.database.Driver()
+
+			if !strings.EqualFold(got, test.want) {
+				t.Errorf("Driver for %s is %v, want %v", test.name, got, test.want)
+			}
+		})
+	}
+}