diff --git a/checker/checker.go b/checker/checker.go index 81f1bcf..3d298bf 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -9,9 +9,7 @@ import ( "strconv" "time" - "github.com/senzing-garage/go-databasing/dbhelper" "github.com/senzing-garage/go-logging/logging" - "github.com/senzing-garage/go-messaging/messenger" "github.com/senzing-garage/go-observing/notifier" "github.com/senzing-garage/go-observing/observer" "github.com/senzing-garage/go-observing/subject" @@ -21,12 +19,11 @@ import ( // Types // ---------------------------------------------------------------------------- -// CheckerImpl is the default implementation of the SqlExecutor interface. -type CheckerImpl struct { +// BasicChecker is the default implementation of the SqlExecutor interface. +type BasicChecker struct { DatabaseConnector driver.Connector isTrace bool logger logging.Logging - messenger messenger.Messenger observerOrigin string observers subject.Subject } @@ -39,11 +36,11 @@ const ( // Variables // ---------------------------------------------------------------------------- -var debugOptions []interface{} = []interface{}{ +var debugOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } -var traceOptions []interface{} = []interface{}{ +var traceOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } @@ -52,8 +49,8 @@ var traceOptions []interface{} = []interface{}{ // ---------------------------------------------------------------------------- // Get the Logger singleton. -func (schemaChecker *CheckerImpl) getLogger() logging.Logging { - var err error = nil +func (schemaChecker *BasicChecker) getLogger() logging.Logging { + var err error if schemaChecker.logger == nil { schemaChecker.logger, err = logging.NewSenzingLogger(ComponentID, IDMessages, baseCallerSkip) if err != nil { @@ -63,33 +60,25 @@ func (schemaChecker *CheckerImpl) getLogger() logging.Logging { return schemaChecker.logger } -// Get the Messenger singleton. -func (schemaChecker *CheckerImpl) getMessenger() messenger.Messenger { - if schemaChecker.messenger == nil { - schemaChecker.messenger = dbhelper.GetMessenger(ComponentID, IDMessages, baseCallerSkip) - } - return schemaChecker.messenger -} - // Log message. -func (schemaChecker *CheckerImpl) log(messageNumber int, details ...interface{}) { +func (schemaChecker *BasicChecker) log(messageNumber int, details ...interface{}) { schemaChecker.getLogger().Log(messageNumber, details...) } // Debug. -func (schemaChecker *CheckerImpl) debug(messageNumber int, details ...interface{}) { +func (schemaChecker *BasicChecker) debug(messageNumber int, details ...interface{}) { details = append(details, debugOptions...) schemaChecker.getLogger().Log(messageNumber, details...) } // Trace method entry. -func (schemaChecker *CheckerImpl) traceEntry(messageNumber int, details ...interface{}) { +func (schemaChecker *BasicChecker) traceEntry(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) schemaChecker.getLogger().Log(messageNumber, details...) } // Trace method exit. -func (schemaChecker *CheckerImpl) traceExit(messageNumber int, details ...interface{}) { +func (schemaChecker *BasicChecker) traceExit(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) schemaChecker.getLogger().Log(messageNumber, details...) } @@ -104,7 +93,7 @@ The IsInstalled verifies that the Senzing schema has been installed. Input - ctx: A context to control lifecycle. */ -func (schemaChecker *CheckerImpl) IsSchemaInstalled(ctx context.Context) (bool, error) { +func (schemaChecker *BasicChecker) IsSchemaInstalled(ctx context.Context) (bool, error) { var ( count int err error @@ -155,7 +144,7 @@ The IsInstalled verifies that the Senzing schema has been installed. Input - ctx: A context to control lifecycle. */ -func (schemaChecker *CheckerImpl) RecordCount(ctx context.Context) (int64, error) { +func (schemaChecker *BasicChecker) RecordCount(ctx context.Context) (int64, error) { var ( count int64 err error @@ -207,7 +196,7 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (schemaChecker *CheckerImpl) RegisterObserver(ctx context.Context, observer observer.Observer) error { +func (schemaChecker *BasicChecker) RegisterObserver(ctx context.Context, observer observer.Observer) error { var err error if schemaChecker.isTrace { entryTime := time.Now() @@ -236,7 +225,7 @@ Input - ctx: A context to control lifecycle. - logLevel: The desired log level. TRACE, DEBUG, INFO, WARN, ERROR, FATAL or PANIC. */ -func (schemaChecker *CheckerImpl) SetLogLevel(ctx context.Context, logLevelName string) error { +func (schemaChecker *BasicChecker) SetLogLevel(ctx context.Context, logLevelName string) error { var err error if schemaChecker.isTrace { entryTime := time.Now() @@ -270,8 +259,8 @@ Input - ctx: A context to control lifecycle. - origin: The value sent in the Observer's "origin" key/value pair. */ -func (schemaChecker *CheckerImpl) SetObserverOrigin(ctx context.Context, origin string) { - var err error = nil +func (schemaChecker *BasicChecker) SetObserverOrigin(ctx context.Context, origin string) { + var err error // Prolog. @@ -299,12 +288,12 @@ func (schemaChecker *CheckerImpl) SetObserverOrigin(ctx context.Context, origin // If DEBUG, log input parameters. Must be done after establishing DEBUG and TRACE logging. - asJson, err := json.Marshal(schemaChecker) + asJSON, err := json.Marshal(schemaChecker) if err != nil { traceExitMessageNumber, debugMessageNumber = 61, 1061 return } - schemaChecker.log(1004, schemaChecker, string(asJson)) + schemaChecker.log(1004, schemaChecker, string(asJSON)) } // Set origin. @@ -331,7 +320,7 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (schemaChecker *CheckerImpl) UnregisterObserver(ctx context.Context, observer observer.Observer) error { +func (schemaChecker *BasicChecker) UnregisterObserver(ctx context.Context, observer observer.Observer) error { var err error if schemaChecker.isTrace { entryTime := time.Now() diff --git a/checker/checker_darwin_test.go b/checker/checker_darwin_test.go index e256b2c..666de22 100644 --- a/checker/checker_darwin_test.go +++ b/checker/checker_darwin_test.go @@ -3,4 +3,4 @@ package checker var sqliteDatabaseFilename = "/tmp/sqlite/G2C.db" -var sqliteDatabaseUrl = "sqlite3://na:na@/tmp/sqlite/G2C.db" +var sqliteDatabaseURL = "sqlite3://na:na@/tmp/sqlite/G2C.db" diff --git a/checker/checker_examples_test.go b/checker/checker_examples_test.go index 494c053..8e7d7fb 100644 --- a/checker/checker_examples_test.go +++ b/checker/checker_examples_test.go @@ -9,21 +9,26 @@ import ( "github.com/senzing-garage/go-databasing/connector" ) +func printErr(err error) { + if err != nil { + fmt.Println(err) + } +} + // ---------------------------------------------------------------------------- // Examples for godoc documentation // ---------------------------------------------------------------------------- -func ExampleCheckerImpl_IsSchemaInstalled() { +func ExampleBasicChecker_IsSchemaInstalled() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/checker/checker_examples_test.go ctx := context.TODO() - databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseUrl) - if err != nil { - fmt.Println(err) - } - testObject := &CheckerImpl{ + databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) + printErr(err) + testObject := &BasicChecker{ DatabaseConnector: databaseConnector, } isSchemaInstalled, err := testObject.IsSchemaInstalled(ctx) + printErr(err) fmt.Printf("isSchemaInstalled: %t", isSchemaInstalled) // Output: isSchemaInstalled: false } diff --git a/checker/checker_linux_test.go b/checker/checker_linux_test.go index 826577c..1477184 100644 --- a/checker/checker_linux_test.go +++ b/checker/checker_linux_test.go @@ -3,4 +3,4 @@ package checker var sqliteDatabaseFilename = "/tmp/sqlite/G2C.db" -var sqliteDatabaseUrl = "sqlite3://na:na@/tmp/sqlite/G2C.db" +var sqliteDatabaseURL = "sqlite3://na:na@/tmp/sqlite/G2C.db" diff --git a/checker/checker_test.go b/checker/checker_test.go index a94e7ce..8446c97 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -8,7 +8,7 @@ import ( "github.com/senzing-garage/go-databasing/connector" "github.com/senzing-garage/go-databasing/sqlexecutor" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // ---------------------------------------------------------------------------- @@ -30,12 +30,12 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } @@ -60,66 +60,44 @@ func refreshSqliteDatabase(databaseFilename string) error { // Test interface functions // ---------------------------------------------------------------------------- -func TestCheckerImpl_IsSchemaInstalled_True(test *testing.T) { +func TestBasicChecker_IsSchemaInstalled_True(test *testing.T) { ctx := context.TODO() // Make a fresh database and create Senzing schema. sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" - refreshSqliteDatabase(sqliteDatabaseFilename) - databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseUrl) - if err != nil { - test.Error(err) - } - sqlExecutor := &sqlexecutor.SqlExecutorImpl{ + err := refreshSqliteDatabase(sqliteDatabaseFilename) + require.NoError(test, err) + databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) + require.NoError(test, err) + sqlExecutor := &sqlexecutor.BasicSQLExecutor{ DatabaseConnector: databaseConnector, } - sqlExecutor.ProcessFileName(ctx, sqlFilename) + err = sqlExecutor.ProcessFileName(ctx, sqlFilename) + require.NoError(test, err) // Perform test. - testObject := &CheckerImpl{ + testObject := &BasicChecker{ DatabaseConnector: databaseConnector, } isSchemaInstalled, err := testObject.IsSchemaInstalled(ctx) if isSchemaInstalled { - if err != nil { - assert.FailNow(test, err.Error()) - } + require.NoError(test, err) } else { - if err == nil { - assert.FailNow(test, "An error should have been returned") - } + require.Error(test, err, "An error should have been returned") } } -func TestCheckerImpl_IsSchemaInstalled_False(test *testing.T) { +func TestBasicChecker_IsSchemaInstalled_False(test *testing.T) { ctx := context.TODO() - - // Make a fresh database with no Senzing schema. - - refreshSqliteDatabase(sqliteDatabaseFilename) - - // Test. - - databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseUrl) - if err != nil { - test.Error(err) - } - testObject := &CheckerImpl{ + err := refreshSqliteDatabase(sqliteDatabaseFilename) + require.NoError(test, err) + databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) + require.NoError(test, err) + testObject := &BasicChecker{ DatabaseConnector: databaseConnector, } - isSchemaInstalled, err := testObject.IsSchemaInstalled(ctx) - if isSchemaInstalled { - if err != nil { - assert.FailNow(test, err.Error()) - } else { - assert.FailNow(test, "Schema is not installed") - } - } else { - if err == nil { - assert.FailNow(test, "Error should have been returned") - } - } - + _, err = testObject.IsSchemaInstalled(ctx) + require.Error(test, err, "An error should have been returned") } diff --git a/checker/checker_windows_test.go b/checker/checker_windows_test.go index 3e2a84d..1322472 100644 --- a/checker/checker_windows_test.go +++ b/checker/checker_windows_test.go @@ -3,4 +3,4 @@ package checker var sqliteDatabaseFilename = `C:\Temp\sqlite\G2C.db` -var sqliteDatabaseUrl = `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db` +var sqliteDatabaseURL = `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db` diff --git a/checker/main.go b/checker/main.go index 090c4d9..a7a8b70 100644 --- a/checker/main.go +++ b/checker/main.go @@ -50,4 +50,4 @@ var IDMessages = map[int]string{ } // Status strings for specific messages. -var IdStatuses = map[int]string{} +var IDStatuses = map[int]string{} diff --git a/connector/connector.go b/connector/connector.go index 482edbc..6d765f6 100644 --- a/connector/connector.go +++ b/connector/connector.go @@ -26,16 +26,16 @@ Input - databaseUrl: A properly formed URL containing database connection information For acceptable database URLs, see https://.... */ -func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, error) { - var result driver.Connector = nil +func NewConnector(ctx context.Context, databaseURL string) (driver.Connector, error) { + var result driver.Connector - parsedUrl, err := url.Parse(databaseUrl) + parsedURL, err := url.Parse(databaseURL) if err != nil { - if strings.HasPrefix(databaseUrl, "postgresql") { - index := strings.LastIndex(databaseUrl, ":") - newDatabaseUrl := databaseUrl[:index] + "/" + databaseUrl[index+1:] - parsedUrl, err = url.Parse(newDatabaseUrl) + if strings.HasPrefix(databaseURL, "postgresql") { + index := strings.LastIndex(databaseURL, ":") + newDatabaseURL := databaseURL[:index] + "/" + databaseURL[index+1:] + parsedURL, err = url.Parse(newDatabaseURL) } if err != nil { @@ -45,13 +45,13 @@ func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, er // Parse URL: https://pkg.go.dev/net/url#URL - scheme := parsedUrl.Scheme - username := parsedUrl.User.Username() - password, isPasswordSet := parsedUrl.User.Password() - path := parsedUrl.Path + scheme := parsedURL.Scheme + username := parsedURL.User.Username() + password, isPasswordSet := parsedURL.User.Password() + path := parsedURL.Path // fragment := parsedUrl.Fragment - host, port, _ := net.SplitHostPort(parsedUrl.Host) - query, err := url.ParseQuery(parsedUrl.RawQuery) + host, port, _ := net.SplitHostPort(parsedURL.Host) + query, err := url.ParseQuery(parsedURL.RawQuery) if err != nil { return result, err } @@ -77,18 +77,18 @@ func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, er configurationMap["port"] = port } if len(path) > 1 { - dbname := strings.Replace(path, "/", "", -1) + dbname := strings.ReplaceAll(path, "/", "") configurationMap["dbname"] = dbname } for key, value := range query { configurationMap[key] = value[0] } - if search_path, ok := query["schema"]; ok { - configurationMap["search_path"] = search_path[0] + if searchPath, ok := query["schema"]; ok { + configurationMap["search_path"] = searchPath[0] } configuration := "" for key, value := range configurationMap { - configuration = configuration + fmt.Sprintf("%s=%s ", key, value) + configuration += fmt.Sprintf("%s=%s ", key, value) } result, err = connectorpostgresql.NewConnector(ctx, configuration) @@ -108,10 +108,10 @@ func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, er configuration.Addr = host } if len(port) > 0 { - configuration.Addr = configuration.Addr + fmt.Sprintf(":%s", port) + configuration.Addr += fmt.Sprintf(":%s", port) } if len(path) > 1 { - dbname := strings.Replace(path, "/", "", -1) + dbname := strings.ReplaceAll(path, "/", "") configuration.DBName = dbname } else if schema, ok := query["schema"]; ok { configuration.DBName = schema[0] @@ -136,7 +136,7 @@ func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, er configurationMap["port"] = port } if len(path) > 1 { - dbname := strings.Replace(path, "/", "", -1) + dbname := strings.ReplaceAll(path, "/", "") configurationMap["database"] = dbname } for key, value := range query { @@ -144,7 +144,7 @@ func NewConnector(ctx context.Context, databaseUrl string) (driver.Connector, er } configuration := "" for key, value := range configurationMap { - configuration = configuration + fmt.Sprintf("%s=%s;", key, value) + configuration += fmt.Sprintf("%s=%s;", key, value) } result, err = connectormssql.NewConnector(ctx, configuration) diff --git a/connector/connector_examples_test.go b/connector/connector_examples_test.go index 2b666b3..aea85e8 100644 --- a/connector/connector_examples_test.go +++ b/connector/connector_examples_test.go @@ -7,6 +7,12 @@ import ( "fmt" ) +func printErr(err error) { + if err != nil { + fmt.Println(err) + } +} + // ---------------------------------------------------------------------------- // Examples for godoc documentation // ---------------------------------------------------------------------------- @@ -14,10 +20,9 @@ import ( func ExampleNewConnector_sqlite() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/connectorpostgresql/connectorpostgresql_examples_test.go ctx := context.TODO() - databaseUrl := "sqlite3://na:na@$/tmp/sqlite/G2C.db" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err, databaseConnector) - } + databaseURL := "sqlite3://na:na@$/tmp/sqlite/G2C.db" + databaseConnector, err := NewConnector(ctx, databaseURL) + printErr(err) + _ = databaseConnector // Faux use of databaseConnector // Output: } diff --git a/connector/connector_test.go b/connector/connector_test.go index edf525b..9c29859 100644 --- a/connector/connector_test.go +++ b/connector/connector_test.go @@ -6,91 +6,85 @@ import ( "os" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -// ---------------------------------------------------------------------------- -// Test harness -// ---------------------------------------------------------------------------- - -func TestMain(m *testing.M) { - err := setup() - if err != nil { - fmt.Print(err) - os.Exit(1) - } - code := m.Run() - err = teardown() - if err != nil { - fmt.Print(err) - } - os.Exit(code) -} - -func setup() error { - var err error = nil - return err -} - -func teardown() error { - var err error = nil - return err -} - // ---------------------------------------------------------------------------- // Test interface functions // ---------------------------------------------------------------------------- func TestNewConnector_sqlite(test *testing.T) { ctx := context.TODO() - databaseUrl := "sqlite3://na:na@/tmp/sqlite/G2C.db" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } + databaseURL := "sqlite3://na:na@/tmp/sqlite/G2C.db" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + } func TestNewConnector_postgresql1(test *testing.T) { ctx := context.TODO() - databaseUrl := "postgresql://username:password@hostname:5432:database/?schema=schemaname" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } + databaseURL := "postgresql://username:password@hostname:5432:database/?schema=schemaname" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + } func TestNewConnector_postgresql2(test *testing.T) { ctx := context.TODO() - databaseUrl := "postgresql://username:password@hostname:5432/database/?schema=schemaname" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } + databaseURL := "postgresql://username:password@hostname:5432/database/?schema=schemaname" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + } func TestNewConnector_mysql1(test *testing.T) { ctx := context.TODO() - databaseUrl := "mysql://username:password@hostname:3306/database?schema=schemaname" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } + databaseURL := "mysql://username:password@hostname:3306/database?schema=schemaname" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + } func TestNewConnector_mysql2(test *testing.T) { ctx := context.TODO() - databaseUrl := "mysql://username:password@hostname:3306/?schema=schemaname" - databaseConnector, err := NewConnector(ctx, databaseUrl) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } + databaseURL := "mysql://username:password@hostname:3306/?schema=schemaname" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + } func TestNewConnector_mssql(test *testing.T) { ctx := context.TODO() - databaseUrl := "mssql://username:password@hostname:3306/database?schema=schemaname" - databaseConnector, err := NewConnector(ctx, databaseUrl) + databaseURL := "mssql://username:password@hostname:3306/database?schema=schemaname" + _, err := NewConnector(ctx, databaseURL) + require.NoError(test, err) + +} + +// ---------------------------------------------------------------------------- +// Test harness +// ---------------------------------------------------------------------------- + +func TestMain(m *testing.M) { + err := setup() if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) + fmt.Print(err) + os.Exit(1) + } + code := m.Run() + err = teardown() + if err != nil { + fmt.Print(err) } + os.Exit(code) +} + +func setup() error { + var err error + return err +} + +func teardown() error { + var err error + return err } diff --git a/connectordb2/connectordb2_test.go b/connectordb2/connectordb2_test.go index 44b8c6a..5f2f0bb 100644 --- a/connectordb2/connectordb2_test.go +++ b/connectordb2/connectordb2_test.go @@ -6,6 +6,19 @@ import ( "testing" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestNewConnector(test *testing.T) { + _ = test + // ctx := context.TODO() + // databaseConnector, err := NewConnector(ctx, "") + // require.NoError(test, err) + // _, err = databaseConnector.Connect(ctx) + // require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -25,27 +38,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestPostgresql_Connect(test *testing.T) { - // ctx := context.TODO() - - // See https://github.com/microsoft/go-mssqldb#connection-parameters-and-dsn - // databaseConnector, err := NewConnector(ctx, "") - // if err != nil { - // test.Fatal(err) - - // } - // databaseConnector.Connect(ctx) -} diff --git a/connectormssql/connectormssql.go b/connectormssql/connectormssql.go index 9cddbc7..ae5352d 100644 --- a/connectormssql/connectormssql.go +++ b/connectormssql/connectormssql.go @@ -18,5 +18,6 @@ Input - configuration: See https://github.com/microsoft/go-mssqldb */ func NewConnector(ctx context.Context, dsn string) (driver.Connector, error) { + _ = ctx return mssql.NewConnector(dsn) } diff --git a/connectormssql/connectormssql_test.go b/connectormssql/connectormssql_test.go index b1a71e0..b2fec2a 100644 --- a/connectormssql/connectormssql_test.go +++ b/connectormssql/connectormssql_test.go @@ -6,9 +6,22 @@ import ( "os" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestNewConnector(test *testing.T) { + ctx := context.TODO() + configuration := "user id=sa;password=Passw0rd;database=G2;server=localhost" + databaseConnector, err := NewConnector(ctx, configuration) + require.NoError(test, err) + _, err = databaseConnector.Connect(ctx) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -28,24 +41,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestNewConnector(test *testing.T) { - ctx := context.TODO() - configuration := "user id=sa;password=Passw0rd;database=G2;server=localhost" - databaseConnector, err := NewConnector(ctx, configuration) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } -} diff --git a/connectormysql/connectormysql.go b/connectormysql/connectormysql.go index 18c432e..903637d 100644 --- a/connectormysql/connectormysql.go +++ b/connectormysql/connectormysql.go @@ -18,5 +18,6 @@ Input - configuration: See https://github.com/go-sql-driver/mysql#dsn-data-source-name */ func NewConnector(ctx context.Context, configuration *mysql.Config) (driver.Connector, error) { + _ = ctx return mysql.NewConnector(configuration) } diff --git a/connectormysql/connectormysql_test.go b/connectormysql/connectormysql_test.go index 9be6859..8c0adec 100644 --- a/connectormysql/connectormysql_test.go +++ b/connectormysql/connectormysql_test.go @@ -7,9 +7,29 @@ import ( "testing" "github.com/go-sql-driver/mysql" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestNewConnector(test *testing.T) { + ctx := context.TODO() + configuration := &mysql.Config{ + User: "root", + Passwd: "root", + Net: "tcp", + Addr: "localhost", + Collation: "utf8mb4_general_ci", + DBName: "G2", + } + databaseConnector, err := NewConnector(ctx, configuration) + require.NoError(test, err) + _, err = databaseConnector.Connect(ctx) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -29,31 +49,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestNewConnector(test *testing.T) { - ctx := context.TODO() - configuration := &mysql.Config{ - User: "root", - Passwd: "root", - Net: "tcp", - Addr: "localhost", - Collation: "utf8mb4_general_ci", - DBName: "G2", - } - databaseConnector, err := NewConnector(ctx, configuration) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } -} diff --git a/connectorpostgresql/connectorpostgresql.go b/connectorpostgresql/connectorpostgresql.go index 7e457bd..8b97c92 100644 --- a/connectorpostgresql/connectorpostgresql.go +++ b/connectorpostgresql/connectorpostgresql.go @@ -18,5 +18,6 @@ Input - dsn: See https://pkg.go.dev/github.com/lib/pq#hdr-Connection_String_Parameters */ func NewConnector(ctx context.Context, dsn string) (driver.Connector, error) { + _ = ctx return pq.NewConnector(dsn) } diff --git a/connectorpostgresql/connectorpostgresql_test.go b/connectorpostgresql/connectorpostgresql_test.go index 4792aba..2e8da90 100644 --- a/connectorpostgresql/connectorpostgresql_test.go +++ b/connectorpostgresql/connectorpostgresql_test.go @@ -6,9 +6,22 @@ import ( "os" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestNewConnector(test *testing.T) { + ctx := context.TODO() + configuration := "user=postgres password=postgres dbname=G2 host=localhost sslmode=disable" + databaseConnector, err := NewConnector(ctx, configuration) + require.NoError(test, err) + _, err = databaseConnector.Connect(ctx) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -28,24 +41,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestNewConnector(test *testing.T) { - ctx := context.TODO() - configuration := "user=postgres password=postgres dbname=G2 host=localhost sslmode=disable" - databaseConnector, err := NewConnector(ctx, configuration) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } -} diff --git a/connectorsqlite/connectorsqlite.go b/connectorsqlite/connectorsqlite.go index bfab5de..5637b08 100644 --- a/connectorsqlite/connectorsqlite.go +++ b/connectorsqlite/connectorsqlite.go @@ -42,6 +42,7 @@ func (connector *Sqlite) Driver() driver.Driver { // ---------------------------------------------------------------------------- func NewConnector(ctx context.Context, filename string) (driver.Connector, error) { + _ = ctx return &Sqlite{ Filename: filename, }, nil diff --git a/connectorsqlite/connectorsqlite_test.go b/connectorsqlite/connectorsqlite_test.go index 5c41a80..d0a6eac 100644 --- a/connectorsqlite/connectorsqlite_test.go +++ b/connectorsqlite/connectorsqlite_test.go @@ -6,9 +6,22 @@ import ( "os" "testing" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestNewConnector(test *testing.T) { + ctx := context.TODO() + configuration := "/tmp/sqlite/G2C.db" + databaseConnector, err := NewConnector(ctx, configuration) + require.NoError(test, err) + _, err = databaseConnector.Connect(ctx) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -28,24 +41,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestNewConnector(test *testing.T) { - ctx := context.TODO() - configuration := "/tmp/sqlite/G2C.db" - databaseConnector, err := NewConnector(ctx, configuration) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } -} diff --git a/dbhelper/dbhelper.go b/dbhelper/dbhelper.go index 790c333..e9e38f1 100644 --- a/dbhelper/dbhelper.go +++ b/dbhelper/dbhelper.go @@ -8,23 +8,23 @@ import ( "github.com/senzing-garage/go-messaging/messenger" ) -func ExtractSqliteDatabaseFilename(databaseUrl string) (string, error) { +func ExtractSqliteDatabaseFilename(databaseURL string) (string, error) { var result = "" - if !strings.HasPrefix(databaseUrl, "sqlite3:") { + if !strings.HasPrefix(databaseURL, "sqlite3:") { return result, fmt.Errorf("sqlite3 URL schema needed") } - parsedUrl, err := url.Parse(databaseUrl) + parsedURL, err := url.Parse(databaseURL) if err != nil { return result, err } - if parsedUrl.Scheme != "sqlite3" { + if parsedURL.Scheme != "sqlite3" { return result, fmt.Errorf("sqlite3 URL schema needed") } - return extractSqliteDatabaseFilenameForOsArch(parsedUrl) + return extractSqliteDatabaseFilenameForOsArch(parsedURL) } func GetMessenger(componentID int, idMessages map[int]string, callerSkip int, options ...interface{}) messenger.Messenger { diff --git a/dbhelper/dbhelper_darwin.go b/dbhelper/dbhelper_darwin.go index a20d68d..29ccde6 100644 --- a/dbhelper/dbhelper_darwin.go +++ b/dbhelper/dbhelper_darwin.go @@ -4,6 +4,6 @@ package dbhelper import "net/url" -func extractSqliteDatabaseFilenameForOsArch(parsedDatabaseUrl *url.URL) (string, error) { - return parsedDatabaseUrl.Path, nil +func extractSqliteDatabaseFilenameForOsArch(parsedDatabaseURL *url.URL) (string, error) { + return parsedDatabaseURL.Path, nil } diff --git a/dbhelper/dbhelper_darwin_test.go b/dbhelper/dbhelper_darwin_test.go index 3c3cfd5..6cc0e6c 100644 --- a/dbhelper/dbhelper_darwin_test.go +++ b/dbhelper/dbhelper_darwin_test.go @@ -5,13 +5,13 @@ package dbhelper var testCasesForOsArch = []testCaseMetadata{ { databaseFilename: "/var/opt/senzing/sqlite/G2C.db", - databaseUrl: "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db", + databaseURL: "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db", name: "sqlite3-001", succeeds: true, }, { databaseFilename: "/var/opt/senzing/sqlite/G2C.db", - databaseUrl: `sqlite3://na:na@hostname/var/opt/senzing/sqlite/G2C.db`, + databaseURL: `sqlite3://na:na@hostname/var/opt/senzing/sqlite/G2C.db`, name: "sqlite3-002", succeeds: true, }, diff --git a/dbhelper/dbhelper_examples_test.go b/dbhelper/dbhelper_examples_test.go index e22735b..b7a0aa9 100644 --- a/dbhelper/dbhelper_examples_test.go +++ b/dbhelper/dbhelper_examples_test.go @@ -4,17 +4,21 @@ package dbhelper import "fmt" +func printErr(err error) { + if err != nil { + fmt.Println(err) + } +} + // ---------------------------------------------------------------------------- // Examples for godoc documentation // ---------------------------------------------------------------------------- func ExampleExtractSqliteDatabaseFilename() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/dbhelper/dbhelper_examples_test.go - databaseUrl := "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db" - databaseFilename, err := ExtractSqliteDatabaseFilename(databaseUrl) - if err != nil { - fmt.Println(err) - } + databaseURL := "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db" + databaseFilename, err := ExtractSqliteDatabaseFilename(databaseURL) + printErr(err) fmt.Println(databaseFilename) // Output: /var/opt/senzing/sqlite/G2C.db } diff --git a/dbhelper/dbhelper_linux.go b/dbhelper/dbhelper_linux.go index 9b18bce..6758418 100644 --- a/dbhelper/dbhelper_linux.go +++ b/dbhelper/dbhelper_linux.go @@ -4,6 +4,6 @@ package dbhelper import "net/url" -func extractSqliteDatabaseFilenameForOsArch(parsedDatabaseUrl *url.URL) (string, error) { - return parsedDatabaseUrl.Path, nil +func extractSqliteDatabaseFilenameForOsArch(parsedDatabaseURL *url.URL) (string, error) { + return parsedDatabaseURL.Path, nil } diff --git a/dbhelper/dbhelper_linux_test.go b/dbhelper/dbhelper_linux_test.go index 089f6ef..76b226e 100644 --- a/dbhelper/dbhelper_linux_test.go +++ b/dbhelper/dbhelper_linux_test.go @@ -5,13 +5,13 @@ package dbhelper var testCasesForOsArch = []testCaseMetadata{ { databaseFilename: "/var/opt/senzing/sqlite/G2C.db", - databaseUrl: "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db", + databaseURL: "sqlite3://na:na@/var/opt/senzing/sqlite/G2C.db", name: "sqlite3-001", succeeds: true, }, { databaseFilename: "/var/opt/senzing/sqlite/G2C.db", - databaseUrl: `sqlite3://na:na@hostname/var/opt/senzing/sqlite/G2C.db`, + databaseURL: `sqlite3://na:na@hostname/var/opt/senzing/sqlite/G2C.db`, name: "sqlite3-002", succeeds: true, }, diff --git a/dbhelper/dbhelper_test.go b/dbhelper/dbhelper_test.go index 6791c77..1cb9828 100644 --- a/dbhelper/dbhelper_test.go +++ b/dbhelper/dbhelper_test.go @@ -10,7 +10,7 @@ import ( type testCaseMetadata struct { databaseFilename string - databaseUrl string + databaseURL string name string succeeds bool } @@ -18,48 +18,64 @@ type testCaseMetadata struct { var testCasesForMultiPlatform = []testCaseMetadata{ { name: "db2-001", - databaseUrl: "db2://username:password@hostname:50000/G2", + databaseURL: "db2://username:password@hostname:50000/G2", succeeds: false, }, { name: "db2-002", - databaseUrl: "db2://username:password@hostname:50000/G2/?schema=schemaname", + databaseURL: "db2://username:password@hostname:50000/G2/?schema=schemaname", succeeds: false, }, { name: "oci-001", - databaseUrl: "oci://username:password@hostname:1521/G2", + databaseURL: "oci://username:password@hostname:1521/G2", succeeds: false, }, { name: "mssql-001", - databaseUrl: "mssql://username:password@hostname:1433/G2", + databaseURL: "mssql://username:password@hostname:1433/G2", succeeds: false, }, { name: "mysql-001", - databaseUrl: "mysql://username:password@hostname:3306/G2", + databaseURL: "mysql://username:password@hostname:3306/G2", succeeds: false, }, { name: "oci-001", - databaseUrl: "oci://username:password@hostname:1521/G2", + databaseURL: "oci://username:password@hostname:1521/G2", succeeds: false, }, { name: "postgresql-001", - databaseUrl: "postgresql://username:password@hostname:5432/G2", + databaseURL: "postgresql://username:password@hostname:5432/G2", succeeds: false, }, { name: "postgresql-002", - databaseUrl: "postgresql://username:password@hostname:5432/G2/?schema=schemaname", + databaseURL: "postgresql://username:password@hostname:5432/G2/?schema=schemaname", succeeds: false, }, } var testCases = append(testCasesForMultiPlatform, testCasesForOsArch...) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestExtractSqliteDatabaseFilename(test *testing.T) { + for _, testCase := range testCases { + test.Run(testCase.name, func(test *testing.T) { + result, err := ExtractSqliteDatabaseFilename(testCase.databaseURL) + testError(test, err, testCase.succeeds) + if len(testCase.databaseFilename) > 0 { + assert.Equal(test, testCase.databaseFilename, result) + } + }) + } +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -79,12 +95,12 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } @@ -104,19 +120,3 @@ func testError(test *testing.T, err error, succeeds bool) { } } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestExtractSqliteDatabaseFilename(test *testing.T) { - for _, testCase := range testCases { - test.Run(testCase.name, func(test *testing.T) { - result, err := ExtractSqliteDatabaseFilename(testCase.databaseUrl) - testError(test, err, testCase.succeeds) - if len(testCase.databaseFilename) > 0 { - assert.Equal(test, testCase.databaseFilename, result) - } - }) - } -} diff --git a/dbhelper/dbhelper_windows_test.go b/dbhelper/dbhelper_windows_test.go index 41f4b8a..cb0346e 100644 --- a/dbhelper/dbhelper_windows_test.go +++ b/dbhelper/dbhelper_windows_test.go @@ -5,25 +5,25 @@ package dbhelper var testCasesForOsArch = []testCaseMetadata{ { databaseFilename: "C:\\Temp\\sqlite\\G2C.db", - databaseUrl: "sqlite3://na:na@nowhere/C:\\Temp\\sqlite\\G2C.db", + databaseURL: "sqlite3://na:na@nowhere/C:\\Temp\\sqlite\\G2C.db", name: "sqlite3-001", succeeds: true, }, { databaseFilename: `C:\Temp\sqlite\G2C.db`, - databaseUrl: "sqlite3://na:na@nowhere/C:\\Temp\\sqlite\\G2C.db", + databaseURL: "sqlite3://na:na@nowhere/C:\\Temp\\sqlite\\G2C.db", name: "sqlite3-002", succeeds: true, }, { databaseFilename: "C:\\Temp\\sqlite\\G2C.db", - databaseUrl: `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db`, + databaseURL: `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db`, name: "sqlite3-003", succeeds: true, }, { databaseFilename: `C:\Temp\sqlite\G2C.db`, - databaseUrl: `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db`, + databaseURL: `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db`, name: "sqlite3-004", succeeds: true, }, diff --git a/main.go b/main.go index 57117c8..66ef92c 100644 --- a/main.go +++ b/main.go @@ -30,9 +30,9 @@ const ( func main() { ctx := context.TODO() - var sqlFilename string = "" - var databaseUrl string = "" - databaseId := Sqlite + var sqlFilename string + var databaseURL string + databaseID := Sqlite // Create a silent observer. @@ -55,30 +55,30 @@ func main() { // Construct database URL and choose SQL file. - switch databaseId { + switch databaseID { case Sqlite: - databaseUrl = sqliteDatabaseUrl + databaseURL = sqliteDatabaseURL sqlFilename = gitRepositoryDir + "/testdata/sqlite/g2core-schema-sqlite-create.sql" case Postgresql: // See https://pkg.go.dev/github.com/lib/pq#hdr-Connection_String_Parameters - databaseUrl = "postgresql://postgres:postgres@localhost/G2/?sslmode=disable" + databaseURL = "postgresql://postgres:postgres@localhost/G2/?sslmode=disable" sqlFilename = gitRepositoryDir + "/testdata/postgresql/g2core-schema-postgresql-create.sql" case Mysql: // See https://pkg.go.dev/github.com/go-sql-driver/mysql#Config - databaseUrl = "mysql://root:root@localhost/G2" // #nosec G101 + databaseURL = "mysql://root:root@localhost/G2" // #nosec G101 sqlFilename = gitRepositoryDir + "/testdata/mysql/g2core-schema-mysql-create.sql" case Mssql: // See https://github.com/microsoft/go-mssqldb#connection-parameters-and-dsn - databaseUrl = "mysql://sa:Passw0rd@localhost/master" + databaseURL = "mysql://sa:Passw0rd@localhost/master" sqlFilename = gitRepositoryDir + "/testdata/mssql/g2core-schema-mssql-create.sql" default: - fmt.Printf("Unknown databaseNumber: %d", databaseId) + fmt.Printf("Unknown databaseNumber: %d", databaseID) os.Exit(1) } // Create database connector. - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) + databaseConnector, err := connector.NewConnector(ctx, databaseURL) if err != nil { fmt.Printf("Could not create a database connector. Error: %v", err) os.Exit(1) @@ -86,7 +86,7 @@ func main() { // Process file of SQL. - testObject := &sqlexecutor.SqlExecutorImpl{ + testObject := &sqlexecutor.BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = testObject.RegisterObserver(ctx, observer1) @@ -102,8 +102,8 @@ func main() { // PostgreSql only tests. - if databaseId == Postgresql { - postgresClient := &postgresql.PostgresqlImpl{ + if databaseID == Postgresql { + postgresClient := &postgresql.BasicPostgresql{ DatabaseConnector: databaseConnector, } err = postgresClient.RegisterObserver(ctx, observer1) diff --git a/main_darwin.go b/main_darwin.go index 034b983..985c144 100644 --- a/main_darwin.go +++ b/main_darwin.go @@ -2,4 +2,4 @@ package main -var sqliteDatabaseUrl = "sqlite3://na:na@/tmp/sqlite/G2C.db" +var sqliteDatabaseURL = "sqlite3://na:na@/tmp/sqlite/G2C.db" diff --git a/main_linux.go b/main_linux.go index a095b11..fb32b04 100644 --- a/main_linux.go +++ b/main_linux.go @@ -2,4 +2,4 @@ package main -var sqliteDatabaseUrl = "sqlite3://na:na@/tmp/sqlite/G2C.db" +var sqliteDatabaseURL = "sqlite3://na:na@/tmp/sqlite/G2C.db" diff --git a/main_test.go b/main_test.go index 219b38b..fb35697 100644 --- a/main_test.go +++ b/main_test.go @@ -7,6 +7,7 @@ import ( /* * The unit tests in this file simulate command line invocation. */ -func TestMain(testing *testing.T) { +func TestMain(test *testing.T) { + _ = test main() } diff --git a/main_windows.go b/main_windows.go index 2e0b653..d7357ed 100644 --- a/main_windows.go +++ b/main_windows.go @@ -2,4 +2,4 @@ package main -var sqliteDatabaseUrl = `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db` +var sqliteDatabaseURL = `sqlite3://na:na@nowhere/C:\Temp\sqlite\G2C.db` diff --git a/postgresql/main.go b/postgresql/main.go index 06ddb9d..18dd740 100644 --- a/postgresql/main.go +++ b/postgresql/main.go @@ -30,7 +30,7 @@ const ComponentID = 6423 // ---------------------------------------------------------------------------- // Message templates for sqlfiler implementation. -var IdMessages = map[int]string{ +var IDMessages = map[int]string{ 1: "Enter GetCurrentWatermark().", 2: "Exit GetCurrentWatermark() returned (%s, %d, %v).", 3: "Enter RegisterObserver(%s).", @@ -46,4 +46,4 @@ var IdMessages = map[int]string{ } // Status strings for specific messages. -var IdStatuses = map[int]string{} +var IDStatuses = map[int]string{} diff --git a/postgresql/postgresql.go b/postgresql/postgresql_basic.go similarity index 77% rename from postgresql/postgresql.go rename to postgresql/postgresql_basic.go index 0a8f560..78fda24 100644 --- a/postgresql/postgresql.go +++ b/postgresql/postgresql_basic.go @@ -19,8 +19,8 @@ import ( // Types // ---------------------------------------------------------------------------- -// PostgresqlImpl is the default implementation of the SqlExecutor interface. -type PostgresqlImpl struct { +// BasicPostgresql is the default implementation of the SqlExecutor interface. +type BasicPostgresql struct { DatabaseConnector driver.Connector isTrace bool logger logging.Logging @@ -32,11 +32,11 @@ type PostgresqlImpl struct { // Variables // ---------------------------------------------------------------------------- -var debugOptions []interface{} = []interface{}{ +var debugOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } -var traceOptions []interface{} = []interface{}{ +var traceOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } @@ -45,13 +45,13 @@ var traceOptions []interface{} = []interface{}{ // ---------------------------------------------------------------------------- // Get the Logger singleton. -func (sqlExecutor *PostgresqlImpl) getLogger() logging.Logging { - var err error = nil +func (sqlExecutor *BasicPostgresql) getLogger() logging.Logging { + var err error if sqlExecutor.logger == nil { options := []interface{}{ &logging.OptionCallerSkip{Value: 4}, } - sqlExecutor.logger, err = logging.NewSenzingLogger(ComponentID, IdMessages, options...) + sqlExecutor.logger, err = logging.NewSenzingLogger(ComponentID, IDMessages, options...) if err != nil { panic(err) } @@ -60,24 +60,24 @@ func (sqlExecutor *PostgresqlImpl) getLogger() logging.Logging { } // Log message. -func (sqlExecutor *PostgresqlImpl) log(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicPostgresql) log(messageNumber int, details ...interface{}) { sqlExecutor.getLogger().Log(messageNumber, details...) } // Debug. -func (sqlExecutor *PostgresqlImpl) debug(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicPostgresql) debug(messageNumber int, details ...interface{}) { details = append(details, debugOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } // Trace method entry. -func (sqlExecutor *PostgresqlImpl) traceEntry(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicPostgresql) traceEntry(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } // Trace method exit. -func (sqlExecutor *PostgresqlImpl) traceExit(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicPostgresql) traceExit(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } @@ -92,26 +92,28 @@ The GetCurrentWatermark does a database call for each line scanned. Input - ctx: A context to control lifecycle. */ -func (sqlExecutor *PostgresqlImpl) GetCurrentWatermark(ctx context.Context) (string, int, error) { +func (sqlExecutor *BasicPostgresql) GetCurrentWatermark(ctx context.Context) (string, int, error) { var ( oid string age int size string + err error ) // Entry tasks. if sqlExecutor.isTrace { + entryTime := time.Now() sqlExecutor.traceEntry(1) + defer func() { sqlExecutor.traceExit(2, oid, age, err, time.Since(entryTime)) }() } - entryTime := time.Now() sqlStatement := "SELECT c.oid::regclass, age(c.relfrozenxid), pg_size_pretty(pg_total_relation_size(c.oid)) FROM pg_class c JOIN pg_namespace n on c.relnamespace = n.oid WHERE relkind IN ('r', 't', 'm') AND n.nspname NOT IN ('pg_toast') ORDER BY 2 DESC LIMIT 1;" // Open a database connection. database := sql.OpenDB(sqlExecutor.DatabaseConnector) defer database.Close() - err := database.PingContext(ctx) + err = database.PingContext(ctx) if err != nil { return "", 0, err } @@ -135,9 +137,7 @@ func (sqlExecutor *PostgresqlImpl) GetCurrentWatermark(ctx context.Context) (str notifier.Notify(ctx, sqlExecutor.observers, sqlExecutor.observerOrigin, ComponentID, 8001, err, details) }() } - if sqlExecutor.isTrace { - defer sqlExecutor.traceExit(2, oid, age, err, time.Since(entryTime)) - } + return oid, age, err } @@ -148,15 +148,18 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (sqlExecutor *PostgresqlImpl) RegisterObserver(ctx context.Context, observer observer.Observer) error { +func (sqlExecutor *BasicPostgresql) RegisterObserver(ctx context.Context, observer observer.Observer) error { + var err error + if sqlExecutor.isTrace { + entryTime := time.Now() sqlExecutor.traceEntry(3, observer.GetObserverID(ctx)) + defer func() { sqlExecutor.traceExit(4, observer.GetObserverID(ctx), err, time.Since(entryTime)) }() } - entryTime := time.Now() if sqlExecutor.observers == nil { sqlExecutor.observers = &subject.SimpleSubject{} } - err := sqlExecutor.observers.RegisterObserver(ctx, observer) + err = sqlExecutor.observers.RegisterObserver(ctx, observer) if sqlExecutor.observers != nil { go func() { details := map[string]string{ @@ -165,9 +168,7 @@ func (sqlExecutor *PostgresqlImpl) RegisterObserver(ctx context.Context, observe notifier.Notify(ctx, sqlExecutor.observers, sqlExecutor.observerOrigin, ComponentID, 8002, err, details) }() } - if sqlExecutor.isTrace { - defer sqlExecutor.traceExit(4, observer.GetObserverID(ctx), err, time.Since(entryTime)) - } + return err } @@ -178,12 +179,14 @@ Input - ctx: A context to control lifecycle. - logLevel: The desired log level. TRACE, DEBUG, INFO, WARN, ERROR, FATAL or PANIC. */ -func (sqlExecutor *PostgresqlImpl) SetLogLevel(ctx context.Context, logLevelName string) error { +func (sqlExecutor *BasicPostgresql) SetLogLevel(ctx context.Context, logLevelName string) error { + var err error + if sqlExecutor.isTrace { + entryTime := time.Now() sqlExecutor.traceEntry(5, logLevelName) + defer func() { sqlExecutor.traceExit(6, logLevelName, err, time.Since(entryTime)) }() } - entryTime := time.Now() - var err error = nil if logging.IsValidLogLevelName(logLevelName) { err = sqlExecutor.getLogger().SetLogLevel(logLevelName) if err != nil { @@ -201,9 +204,7 @@ func (sqlExecutor *PostgresqlImpl) SetLogLevel(ctx context.Context, logLevelName } else { err = fmt.Errorf("invalid error level: %s", logLevelName) } - if sqlExecutor.isTrace { - defer sqlExecutor.traceExit(6, logLevelName, err, time.Since(entryTime)) - } + return err } @@ -214,8 +215,8 @@ Input - ctx: A context to control lifecycle. - origin: The value sent in the Observer's "origin" key/value pair. */ -func (sqlExecutor *PostgresqlImpl) SetObserverOrigin(ctx context.Context, origin string) { - var err error = nil +func (sqlExecutor *BasicPostgresql) SetObserverOrigin(ctx context.Context, origin string) { + var err error // Prolog. @@ -243,12 +244,12 @@ func (sqlExecutor *PostgresqlImpl) SetObserverOrigin(ctx context.Context, origin // If DEBUG, log input parameters. Must be done after establishing DEBUG and TRACE logging. - asJson, err := json.Marshal(sqlExecutor) + asJSON, err := json.Marshal(sqlExecutor) if err != nil { traceExitMessageNumber, debugMessageNumber = 61, 1061 return } - sqlExecutor.log(1004, sqlExecutor, string(asJson)) + sqlExecutor.log(1004, sqlExecutor, string(asJSON)) } // Set origin. @@ -275,12 +276,14 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (sqlExecutor *PostgresqlImpl) UnregisterObserver(ctx context.Context, observer observer.Observer) error { +func (sqlExecutor *BasicPostgresql) UnregisterObserver(ctx context.Context, observer observer.Observer) error { + var err error + if sqlExecutor.isTrace { + entryTime := time.Now() sqlExecutor.traceEntry(7, observer.GetObserverID(ctx)) + defer func() { sqlExecutor.traceExit(8, observer.GetObserverID(ctx), err, time.Since(entryTime)) }() } - entryTime := time.Now() - var err error = nil if sqlExecutor.observers != nil { // Tricky code: // client.notify is called synchronously before client.observers is set to nil. @@ -295,8 +298,6 @@ func (sqlExecutor *PostgresqlImpl) UnregisterObserver(ctx context.Context, obser if !sqlExecutor.observers.HasObservers(ctx) { sqlExecutor.observers = nil } - if sqlExecutor.isTrace { - defer sqlExecutor.traceExit(8, observer.GetObserverID(ctx), err, time.Since(entryTime)) - } + return err } diff --git a/postgresql/postgresql_examples_test.go b/postgresql/postgresql_examples_test.go index cd5889c..b372bec 100644 --- a/postgresql/postgresql_examples_test.go +++ b/postgresql/postgresql_examples_test.go @@ -13,7 +13,7 @@ import ( // Examples for godoc documentation // ---------------------------------------------------------------------------- -func ExamplePostgresqlImpl_GetCurrentWatermark() { +func ExampleBasicPostgresql_GetCurrentWatermark() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/postgresql/postgresql_examples_test.go ctx := context.TODO() // See https://pkg.go.dev/github.com/lib/pq#hdr-Connection_String_Parameters @@ -22,7 +22,7 @@ func ExamplePostgresqlImpl_GetCurrentWatermark() { if err != nil { fmt.Println(err) } - database := &PostgresqlImpl{ + database := &BasicPostgresql{ DatabaseConnector: databaseConnector, } oid, age, err := database.GetCurrentWatermark(ctx) diff --git a/postgresql/postgresql_test.go b/postgresql/postgresql_test.go index df7dfb7..c4528e1 100644 --- a/postgresql/postgresql_test.go +++ b/postgresql/postgresql_test.go @@ -8,9 +8,32 @@ import ( "github.com/senzing-garage/go-databasing/connectorpostgresql" "github.com/senzing-garage/go-observing/observer" - "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestPostgresqlImpl_GetCurrentWatermark(test *testing.T) { + ctx := context.TODO() + observer1 := &observer.NullObserver{ + ID: "Observer 1", + IsSilent: true, + } + configuration := "user=postgres password=postgres dbname=G2 host=localhost sslmode=disable" + databaseConnector, err := connectorpostgresql.NewConnector(ctx, configuration) + require.NoError(test, err) + testObject := &BasicPostgresql{ + DatabaseConnector: databaseConnector, + } + err = testObject.RegisterObserver(ctx, observer1) + require.NoError(test, err) + testObject.SetObserverOrigin(ctx, "Test") + _, _, err = testObject.GetCurrentWatermark(ctx) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -30,40 +53,11 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestPostgresqlImpl_GetCurrentWatermark(test *testing.T) { - ctx := context.TODO() - observer1 := &observer.NullObserver{ - ID: "Observer 1", - IsSilent: true, - } - configuration := "user=postgres password=postgres dbname=G2 host=localhost sslmode=disable" - databaseConnector, err := connectorpostgresql.NewConnector(ctx, configuration) - if err != nil { - assert.FailNow(test, err.Error(), databaseConnector) - } - testObject := &PostgresqlImpl{ - DatabaseConnector: databaseConnector, - } - err = testObject.RegisterObserver(ctx, observer1) - if err != nil { - assert.FailNow(test, err.Error()) - } - testObject.SetObserverOrigin(ctx, "Test") - oid, age, err := testObject.GetCurrentWatermark(ctx) - if err != nil { - assert.FailNow(test, err.Error(), oid, age) - } -} diff --git a/sqlexecutor/main.go b/sqlexecutor/main.go index 763a480..73a9cc0 100644 --- a/sqlexecutor/main.go +++ b/sqlexecutor/main.go @@ -11,7 +11,7 @@ import ( // Types // ---------------------------------------------------------------------------- -type SqlExecutor interface { +type SQLExecutor interface { ProcessFileName(ctx context.Context, filename string) error ProcessScanner(ctx context.Context, scanner *bufio.Scanner) error RegisterObserver(ctx context.Context, observer observer.Observer) error @@ -32,7 +32,7 @@ const ComponentID = 6422 // ---------------------------------------------------------------------------- // Message templates for sqlfiler implementation. -var IdMessages = map[int]string{ +var IDMessages = map[int]string{ 1: "Enter ProcessFileName(%s).", 2: "Exit ProcessFileName(%s) returned (%v).", 3: "Enter ProcessScanner().", @@ -56,4 +56,4 @@ var IdMessages = map[int]string{ } // Status strings for specific messages. -var IdStatuses = map[int]string{} +var IDStatuses = map[int]string{} diff --git a/sqlexecutor/sqlexecutor.go b/sqlexecutor/sqlexecutor_basic.go similarity index 85% rename from sqlexecutor/sqlexecutor.go rename to sqlexecutor/sqlexecutor_basic.go index 6b44ccc..a7e7d88 100644 --- a/sqlexecutor/sqlexecutor.go +++ b/sqlexecutor/sqlexecutor_basic.go @@ -22,9 +22,9 @@ import ( // Types // ---------------------------------------------------------------------------- -// SqlExecutorImpl is the default implementation of the SqlExecutor interface. -type SqlExecutorImpl struct { - DatabaseConnector driver.Connector +// BasicSQLExecutor is the default implementation of the SqlExecutor interface. +type BasicSQLExecutor struct { + DatabaseConnector driver.Connector `json:"databaseConnector,omitempty"` isTrace bool logger logging.Logging observerOrigin string @@ -35,11 +35,11 @@ type SqlExecutorImpl struct { // Variables // ---------------------------------------------------------------------------- -var debugOptions []interface{} = []interface{}{ +var debugOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } -var traceOptions []interface{} = []interface{}{ +var traceOptions = []interface{}{ &logging.OptionCallerSkip{Value: 5}, } @@ -50,13 +50,13 @@ var traceOptions []interface{} = []interface{}{ // --- Logging ---------------------------------------------------------------- // Get the Logger singleton. -func (sqlExecutor *SqlExecutorImpl) getLogger() logging.Logging { - var err error = nil +func (sqlExecutor *BasicSQLExecutor) getLogger() logging.Logging { + var err error if sqlExecutor.logger == nil { options := []interface{}{ &logging.OptionCallerSkip{Value: 4}, } - sqlExecutor.logger, err = logging.NewSenzingLogger(ComponentID, IdMessages, options...) + sqlExecutor.logger, err = logging.NewSenzingLogger(ComponentID, IDMessages, options...) if err != nil { panic(err) } @@ -65,24 +65,24 @@ func (sqlExecutor *SqlExecutorImpl) getLogger() logging.Logging { } // Log message. -func (sqlExecutor *SqlExecutorImpl) log(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicSQLExecutor) log(messageNumber int, details ...interface{}) { sqlExecutor.getLogger().Log(messageNumber, details...) } // Debug. -func (sqlExecutor *SqlExecutorImpl) debug(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicSQLExecutor) debug(messageNumber int, details ...interface{}) { details = append(details, debugOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } // Trace method entry. -func (sqlExecutor *SqlExecutorImpl) traceEntry(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicSQLExecutor) traceEntry(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } // Trace method exit. -func (sqlExecutor *SqlExecutorImpl) traceExit(messageNumber int, details ...interface{}) { +func (sqlExecutor *BasicSQLExecutor) traceExit(messageNumber int, details ...interface{}) { details = append(details, traceOptions...) sqlExecutor.getLogger().Log(messageNumber, details...) } @@ -98,7 +98,7 @@ Input - ctx: A context to control lifecycle. - filename: A fully qualified path to a file of SQL statements. */ -func (sqlExecutor *SqlExecutorImpl) ProcessFileName(ctx context.Context, filename string) error { +func (sqlExecutor *BasicSQLExecutor) ProcessFileName(ctx context.Context, filename string) error { var err error @@ -147,7 +147,7 @@ Input - ctx: A context to control lifecycle. - scanner: SQL statements to be processed. */ -func (sqlExecutor *SqlExecutorImpl) ProcessScanner(ctx context.Context, scanner *bufio.Scanner) error { +func (sqlExecutor *BasicSQLExecutor) ProcessScanner(ctx context.Context, scanner *bufio.Scanner) error { var ( err error @@ -175,11 +175,11 @@ func (sqlExecutor *SqlExecutorImpl) ProcessScanner(ctx context.Context, scanner // Process each scanned line. for scanner.Scan() { - scanLine += 1 + scanLine++ sqlText := scanner.Text() result, err := database.ExecContext(ctx, sqlText) if err != nil { - scanFailure += 1 + scanFailure++ sqlExecutor.log(3001, scanFailure, scanLine, result, err) } if sqlExecutor.observers != nil { @@ -224,7 +224,7 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (sqlExecutor *SqlExecutorImpl) RegisterObserver(ctx context.Context, observer observer.Observer) error { +func (sqlExecutor *BasicSQLExecutor) RegisterObserver(ctx context.Context, observer observer.Observer) error { var err error if sqlExecutor.isTrace { @@ -261,7 +261,7 @@ Input - ctx: A context to control lifecycle. - logLevelName: The desired log level as string: "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL" or "PANIC". */ -func (sqlExecutor *SqlExecutorImpl) SetLogLevel(ctx context.Context, logLevelName string) error { +func (sqlExecutor *BasicSQLExecutor) SetLogLevel(ctx context.Context, logLevelName string) error { var err error if sqlExecutor.isTrace { @@ -297,8 +297,8 @@ Input - ctx: A context to control lifecycle. - origin: The value sent in the Observer's "origin" key/value pair. */ -func (sqlExecutor *SqlExecutorImpl) SetObserverOrigin(ctx context.Context, origin string) { - var err error = nil +func (sqlExecutor *BasicSQLExecutor) SetObserverOrigin(ctx context.Context, origin string) { + var err error // Prolog. @@ -326,12 +326,12 @@ func (sqlExecutor *SqlExecutorImpl) SetObserverOrigin(ctx context.Context, origi // If DEBUG, log input parameters. Must be done after establishing DEBUG and TRACE logging. - asJson, err := json.Marshal(sqlExecutor) + asJSON, err := json.Marshal(sqlExecutor) if err != nil { traceExitMessageNumber, debugMessageNumber = 61, 1061 return } - sqlExecutor.log(1004, sqlExecutor, string(asJson)) + sqlExecutor.log(1004, sqlExecutor, string(asJSON)) } // Set origin. @@ -358,8 +358,8 @@ Input - ctx: A context to control lifecycle. - observer: The observer to be added. */ -func (sqlExecutor *SqlExecutorImpl) UnregisterObserver(ctx context.Context, observer observer.Observer) error { - var err error = nil +func (sqlExecutor *BasicSQLExecutor) UnregisterObserver(ctx context.Context, observer observer.Observer) error { + var err error if sqlExecutor.isTrace { entryTime := time.Now() diff --git a/sqlexecutor/sqlexecutor_examples_test.go b/sqlexecutor/sqlexecutor_examples_test.go index 99f7577..97fe7c7 100644 --- a/sqlexecutor/sqlexecutor_examples_test.go +++ b/sqlexecutor/sqlexecutor_examples_test.go @@ -11,113 +11,99 @@ import ( "github.com/senzing-garage/go-databasing/connector" ) +func printErr(err error) { + if err != nil { + fmt.Println(err) + } +} + // ---------------------------------------------------------------------------- // Examples for godoc documentation // ---------------------------------------------------------------------------- -func ExampleSqlExecutorImpl_ProcessFileName_mysql() { +func ExampleBasicSQLExecutor_ProcessFileName_mysql() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/sqlexecutor/sqlexecutor_examples_test.go ctx := context.TODO() // See https://pkg.go.dev/github.com/go-sql-driver/mysql#Config - databaseUrl := "mysql://root:root@localhost:3306/G2" + databaseURL := "mysql://root:root@localhost:3306/G2" // #nosec G101 sqlFilename := "../testdata/mysql/g2core-schema-mysql-create.sql" - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err) - } - sqlExecutor := &SqlExecutorImpl{ + databaseConnector, err := connector.NewConnector(ctx, databaseURL) + printErr(err) + sqlExecutor := &BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = sqlExecutor.ProcessFileName(ctx, sqlFilename) - if err != nil { - fmt.Println(err) - } + printErr(err) // Output: } -func ExampleSqlExecutorImpl_ProcessFileName_postgresql() { +func ExampleBasicSQLExecutor_ProcessFileName_postgresql() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/sqlexecutor/sqlexecutor_examples_test.go ctx := context.TODO() // See https://pkg.go.dev/github.com/lib/pq#hdr-Connection_String_Parameters - databaseUrl := "postgresql://postgres:postgres@localhost:5432/G2/?sslmode=disable" + databaseURL := "postgresql://postgres:postgres@localhost:5432/G2/?sslmode=disable" sqlFilename := "../testdata/postgresql/g2core-schema-postgresql-create.sql" - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err) - } - sqlExecutor := &SqlExecutorImpl{ + databaseConnector, err := connector.NewConnector(ctx, databaseURL) + printErr(err) + sqlExecutor := &BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = sqlExecutor.ProcessFileName(ctx, sqlFilename) - if err != nil { - fmt.Println(err) - } + printErr(err) // Output: } -func ExampleSqlExecutorImpl_ProcessFileName_mssql() { +func ExampleBasicSQLExecutor_ProcessFileName_mssql() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/sqlexecutor/sqlexecutor_examples_test.go ctx := context.TODO() // See https://github.com/microsoft/go-mssqldb#connection-parameters-and-dsn - databaseUrl := "mssql://sa:Passw0rd@localhost:1433/master" + databaseURL := "mssql://sa:Passw0rd@localhost:1433/master" sqlFilename := "../testdata/mssql/g2core-schema-mssql-create.sql" - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err) - } - sqlExecutor := &SqlExecutorImpl{ + databaseConnector, err := connector.NewConnector(ctx, databaseURL) + printErr(err) + sqlExecutor := &BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = sqlExecutor.ProcessFileName(ctx, sqlFilename) - if err != nil { - fmt.Println(err) - } + printErr(err) // Output: } -func ExampleSqlExecutorImpl_ProcessFileName_sqlite() { +func ExampleBasicSQLExecutor_ProcessFileName_sqlite() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/sqlexecutor/sqlexecutor_examples_test.go ctx := context.TODO() databaseFilename := "/tmp/sqlite/G2C.db" - databaseUrl := fmt.Sprintf("sqlite3://na:na@%s", databaseFilename) + databaseURL := fmt.Sprintf("sqlite3://na:na@%s", databaseFilename) sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" - refreshSqliteDatabase(databaseFilename) // Only needed for repeatable test cases. - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err) - } - sqlExecutor := &SqlExecutorImpl{ + err := refreshSqliteDatabase(databaseFilename) // Only needed for repeatable test cases. + printErr(err) + databaseConnector, err := connector.NewConnector(ctx, databaseURL) + printErr(err) + sqlExecutor := &BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = sqlExecutor.ProcessFileName(ctx, sqlFilename) - if err != nil { - fmt.Println(err) - } + printErr(err) // Output: } -func ExampleSqlExecutorImpl_ProcessScanner_sqlite() { +func ExampleBasicSQLExecutor_ProcessScanner_sqlite() { // For more information, visit https://github.com/senzing-garage/go-databasing/blob/main/sqlexecutor/sqlexecutor_examples_test.go ctx := context.TODO() databaseFilename := "/tmp/sqlite/G2C.db" - databaseUrl := fmt.Sprintf("sqlite3://na:na@%s", databaseFilename) + databaseURL := fmt.Sprintf("sqlite3://na:na@%s", databaseFilename) sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" - refreshSqliteDatabase(databaseFilename) // Only needed for repeatable test cases. + err := refreshSqliteDatabase(databaseFilename) // Only needed for repeatable test cases. + printErr(err) file, err := os.Open(sqlFilename) - if err != nil { - fmt.Println(err) - } + printErr(err) defer file.Close() - databaseConnector, err := connector.NewConnector(ctx, databaseUrl) - if err != nil { - fmt.Println(err) - } - sqlExecutor := &SqlExecutorImpl{ + databaseConnector, err := connector.NewConnector(ctx, databaseURL) + printErr(err) + sqlExecutor := &BasicSQLExecutor{ DatabaseConnector: databaseConnector, } err = sqlExecutor.ProcessScanner(ctx, bufio.NewScanner(file)) - if err != nil { - fmt.Println(err) - } + printErr(err) // Output: } diff --git a/sqlexecutor/sqlexecutor_test.go b/sqlexecutor/sqlexecutor_test.go index a540b3f..2f617f2 100644 --- a/sqlexecutor/sqlexecutor_test.go +++ b/sqlexecutor/sqlexecutor_test.go @@ -12,6 +12,53 @@ import ( "github.com/stretchr/testify/require" ) +// ---------------------------------------------------------------------------- +// Test interface functions +// ---------------------------------------------------------------------------- + +func TestSqlExecutorImpl_ProcessFileName(test *testing.T) { + ctx := context.TODO() + sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" + err := refreshSqliteDatabase(sqliteDatabaseFilename) + require.NoError(test, err) + observer1 := &observer.NullObserver{ + ID: "Observer 1", + IsSilent: true, + } + databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) + require.NoError(test, err) + testObject := &BasicSQLExecutor{ + DatabaseConnector: databaseConnector, + } + err = testObject.RegisterObserver(ctx, observer1) + require.NoError(test, err) + testObject.SetObserverOrigin(ctx, "Test") + err = testObject.ProcessFileName(ctx, sqlFilename) + require.NoError(test, err) +} + +func TestSqlExecutorImpl_ProcessScanner(test *testing.T) { + ctx := context.TODO() + sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" + err := refreshSqliteDatabase(sqliteDatabaseFilename) + require.NoError(test, err) + file, err := os.Open(sqlFilename) + defer func() { + err = file.Close() + if err != nil { + panic(err) + } + }() + require.NoError(test, err) + databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) + require.NoError(test, err) + testObject := &BasicSQLExecutor{ + DatabaseConnector: databaseConnector, + } + err = testObject.ProcessScanner(ctx, bufio.NewScanner(file)) + require.NoError(test, err) +} + // ---------------------------------------------------------------------------- // Test harness // ---------------------------------------------------------------------------- @@ -31,12 +78,12 @@ func TestMain(m *testing.M) { } func setup() error { - var err error = nil + var err error return err } func teardown() error { - var err error = nil + var err error return err } @@ -56,51 +103,3 @@ func refreshSqliteDatabase(databaseFilename string) error { file.Close() return nil } - -// ---------------------------------------------------------------------------- -// Test interface functions -// ---------------------------------------------------------------------------- - -func TestSqlExecutorImpl_ProcessFileName(test *testing.T) { - ctx := context.TODO() - sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" - err := refreshSqliteDatabase(sqliteDatabaseFilename) - require.NoError(test, err) - observer1 := &observer.NullObserver{ - ID: "Observer 1", - IsSilent: true, - } - databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) - if err != nil { - test.Error(err) - } - testObject := &SqlExecutorImpl{ - DatabaseConnector: databaseConnector, - } - err = testObject.RegisterObserver(ctx, observer1) - require.NoError(test, err) - testObject.SetObserverOrigin(ctx, "Test") - err = testObject.ProcessFileName(ctx, sqlFilename) - require.NoError(test, err) -} - -func TestSqlExecutorImpl_ProcessScanner(test *testing.T) { - ctx := context.TODO() - sqlFilename := "../testdata/sqlite/g2core-schema-sqlite-create.sql" - refreshSqliteDatabase(sqliteDatabaseFilename) - file, err := os.Open(sqlFilename) - defer func() { - err = file.Close() - if err != nil { - panic(err) - } - }() - require.NoError(test, err) - databaseConnector, err := connector.NewConnector(ctx, sqliteDatabaseURL) - require.NoError(test, err) - testObject := &SqlExecutorImpl{ - DatabaseConnector: databaseConnector, - } - err = testObject.ProcessScanner(ctx, bufio.NewScanner(file)) - require.NoError(test, err) -}