WIP handle locked database + unit test

database/database.go

@@ -75,7 +75,7 @@ type DBError struct {
 	Err error
 }
 
-func (e *DBError) Error() string {
+func (e DBError) Error() string {
 	return fmt.Sprintf("<%s>: %s", e.D.Name, e.Err)
 }
 
@@ -178,10 +178,19 @@ func (db *DB) Init() (*DB, error) {
 		return db, nil
 	}
 
-	db.Open()
+	// Open database
+	err = db.Open()
 
+	sqlErr, _ := err.(sqlite3.Error)
+
+	// If database is locked, try to unlock it
+	if err != nil && sqlErr.Code == sqlite3.ErrBusy {
+		log.Debug("DB IS LOCKED !!!!")
+	}
+
+	// Return all other errors
 	if err != nil {
-		return nil, &DBError{D: db, Err: err}
+		return nil, DBError{D: db, Err: err}
 	}
 
 	// We don't initialize schema for a foreing db
@@ -192,20 +201,20 @@ func (db *DB) Init() (*DB, error) {
 	// Populate db schema
 	tx, err := db.Handle.Begin()
 	if err != nil {
-		return nil, &DBError{D: db, Err: err}
+		return nil, DBError{D: db, Err: err}
 	}
 
 	stmt, err := tx.Prepare(QCreateGomarkDBSchema)
 	if err != nil {
-		return nil, &DBError{D: db, Err: err}
+		return nil, DBError{D: db, Err: err}
 	}
 
 	if _, err = stmt.Exec(); err != nil {
-		return nil, &DBError{D: db, Err: err}
+		return nil, DBError{D: db, Err: err}
 	}
 
 	if err = tx.Commit(); err != nil {
-		return nil, &DBError{D: db, Err: err}
+		return nil, DBError{D: db, Err: err}
 	}
 
 	log.Debugf("<%s> initialized", db.Name)

database/database_test.go

@@ -4,24 +4,54 @@ import (
 	"fmt"
 	"os"
 	"testing"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/mattn/go-sqlite3"
 )
 
 const (
 	TestDB = "testdata/gomarkdb_test.sqlite"
 )
 
-func TestInitDB(t *testing.T) {
+type LockedSQLXOpener struct {
+	handle *sqlx.DB
+	err    sqlite3.Error
+}
+
+func (o *LockedSQLXOpener) Open(driver string, dsn string) error {
+	return o.err
+
+}
+
+func (o *LockedSQLXOpener) Get() *sqlx.DB {
+	return nil
+}
+
+// We
+func TestDBLocked(t *testing.T) {
+	lockedOpener := &LockedSQLXOpener{
+		handle: nil,
+		err:    sqlite3.Error{Code: sqlite3.ErrBusy},
+	}
+
 	testDB := &DB{
 		Name:       "test",
 		Path:       fmt.Sprintf(MemcacheFmt, "test"),
-		Handle:     nil,
 		EngineMode: DriverDefault,
+		SQLXOpener: lockedOpener,
+	}
+
+	_, err := testDB.Init()
+	if err != nil {
+		e, _ := err.(DBError).Err.(sqlite3.Error)
+
+		if e.Code == sqlite3.ErrBusy {
+			t.Error("should handle locked database")
+		} else {
+			t.Error(err)
+		}
 	}
 
-	//db.In
-	// Try to open locked db
-	t.Error("test if database is not locked")
-	t.Error("test if db path is not found")
 }
 
 func TestGomarkDBCeate(t *testing.T) {