Rename package from atomic to satomic

error.go

@@ -1,4 +1,4 @@
-package atomic
+package satomic
 
 import (
 	"fmt"

error_test.go

@@ -1,29 +1,29 @@
-package atomic_test
+package satomic_test
 
 import (
 	"errors"
 	"testing"
 )
 
 import (
-	atomic "github.com/dhui/satomic"
-	"github.com/dhui/satomic/atomictest"
+	"github.com/dhui/satomic"
+	"github.com/dhui/satomic/satomictest"
 )
 
 func TestError(t *testing.T) {
 	testCases := []struct {
 		name        string
-		err         *atomic.Error
+		err         *satomic.Error
 		expectedStr string
 	}{
 		{name: "nil Error", err: nil, expectedStr: ""},
-		{name: "nil Err and Atomic", err: atomictest.NewError(nil, nil),
+		{name: "nil Err and Atomic", err: satomictest.NewError(nil, nil),
 			expectedStr: `Err: <nil> Atomic: <nil>`},
-		{name: "nil Err, non-nil Atomic", err: atomictest.NewError(nil, errors.New("atomic")),
+		{name: "nil Err, non-nil Atomic", err: satomictest.NewError(nil, errors.New("atomic")),
 			expectedStr: `Err: <nil> Atomic: "atomic"`},
-		{name: "non-nil Err, nil Atomic", err: atomictest.NewError(errors.New("err"), nil),
+		{name: "non-nil Err, nil Atomic", err: satomictest.NewError(errors.New("err"), nil),
 			expectedStr: `Err: "err" Atomic: <nil>`},
-		{name: "non-nil Err and Atomic", err: atomictest.NewError(errors.New("err"), errors.New("atomic")),
+		{name: "non-nil Err and Atomic", err: satomictest.NewError(errors.New("err"), errors.New("atomic")),
 			expectedStr: `Err: "err" Atomic: "atomic"`},
 	}
 

example_test.go

@@ -1,4 +1,4 @@
-package atomic_test
+package satomic_test
 
 import (
 	"context"
@@ -13,7 +13,7 @@ import (
 )
 
 import (
-	atomic "github.com/dhui/satomic"
+	"github.com/dhui/satomic"
 	"github.com/dhui/satomic/savepointers/mock"
 )
 
@@ -46,40 +46,40 @@ func Example() {
 
 	ctx := context.Background()
 	// For actual code, use a real Savepointer instead of a mocked one
-	q, err := atomic.NewQuerier(ctx, db, mock.NewSavepointer(os.Stdout, true), sql.TxOptions{})
+	q, err := satomic.NewQuerier(ctx, db, mock.NewSavepointer(os.Stdout, true), sql.TxOptions{})
 	if err != nil {
 		fmt.Println("Error creating querier:", err)
 		return
 	}
-	if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+	if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 		var dummy int
 		if err := q.QueryRowContext(ctx, "SELECT 1;").Scan(&dummy); err != nil {
 			fmt.Println(err)
 		}
 		// SAVEPOINT 1
-		if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+		if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 			return q.QueryRowContext(ctx, "SELECT 2;").Scan(&dummy)
 		}); err != nil {
 			fmt.Println(err)
 		}
 		// SAVEPOINT 2
-		if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+		if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 			return q.QueryRowContext(ctx, "SELECT 3;").Scan(&dummy)
 		}); err != nil {
 			fmt.Println(err)
 		}
 		// SAVEPOINT 3
-		if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+		if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 			if err := q.QueryRowContext(ctx, "SELECT 4;").Scan(&dummy); err != nil {
 				fmt.Println(err)
 			}
 			// SAVEPOINT 4
-			if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+			if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 				if err := q.QueryRowContext(ctx, "SELECT 5;").Scan(&dummy); err != nil {
 					fmt.Println(err)
 				}
 				// SAVEPOINT 5
-				if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+				if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 					return q.QueryRowContext(ctx, "SELECT 6;").Scan(&dummy)
 				}); err != nil {
 					fmt.Println(err)

atomic.go → satomic.go

@@ -1,5 +1,5 @@
-// Package atomic provides a easy way to nest atomic SQL updates using transactions and savepoints
-package atomic
+// Package satomic provides a easy way to nest atomic SQL updates using transactions and savepoints
+package satomic
 
 import (
 	"context"

atomic_internal_test.go → satomic_internal_test.go

@@ -1,4 +1,4 @@
-package atomic
+package satomic
 
 import (
 	"context"

atomic_test.go → satomic_test.go

@@ -1,4 +1,4 @@
-package atomic_test
+package satomic_test
 
 import (
 	"context"
@@ -13,8 +13,8 @@ import (
 )
 
 import (
-	atomic "github.com/dhui/satomic"
-	"github.com/dhui/satomic/atomictest"
+	"github.com/dhui/satomic"
+	"github.com/dhui/satomic/satomictest"
 	"github.com/dhui/satomic/savepointers"
 	"github.com/dhui/satomic/savepointers/mock"
 )
@@ -30,26 +30,26 @@ func TestDefaultQuerierAtomicBeginErr(t *testing.T) {
 	_sqlmock.ExpectBegin().WillReturnError(expectedErr)
 
 	ctx := context.Background()
-	if _, err := atomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true),
+	if _, err := satomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true),
 		sql.TxOptions{}); err != expectedErr {
 		t.Error("Didn't get the expected error:", err, "!=", expectedErr)
 	}
 }
 
 func TestDefaultQuerierAtomicNoSavepoint(t *testing.T) {
 	selectErr := errors.New("select 1 error")
-	expectedSelectErr := atomictest.NewError(selectErr, nil)
+	expectedSelectErr := satomictest.NewError(selectErr, nil)
 
 	rbErr := errors.New("rollback error")
-	expectedRbErr := atomictest.NewError(selectErr, rbErr)
+	expectedRbErr := satomictest.NewError(selectErr, rbErr)
 
 	commitErr := errors.New("commit error")
-	expectedCommitErr := atomictest.NewError(nil, commitErr)
+	expectedCommitErr := satomictest.NewError(nil, commitErr)
 
 	testCases := []struct {
 		name        string
 		mocker      func(sqlmock.Sqlmock) sqlmock.Sqlmock
-		expectedErr *atomic.Error
+		expectedErr *satomic.Error
 	}{
 		{name: "success", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin()
@@ -88,14 +88,14 @@ func TestDefaultQuerierAtomicNoSavepoint(t *testing.T) {
 
 			_sqlmock = tc.mocker(_sqlmock)
 
-			q, err := atomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true), sql.TxOptions{})
+			q, err := satomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true), sql.TxOptions{})
 			if err != nil {
 				t.Fatal("Error creating Querier:", err)
 			}
-			if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+			if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 				var dummy int
 				return q.QueryRowContext(ctx, "SELECT 1;").Scan(&dummy)
-			}); !atomictest.ErrsEq(err, tc.expectedErr) {
+			}); !satomictest.ErrsEq(err, tc.expectedErr) {
 				t.Errorf("Didn't get the expected error: %+v != %+v", err, tc.expectedErr)
 			}
 
@@ -108,13 +108,13 @@ func TestDefaultQuerierAtomicNoSavepoint(t *testing.T) {
 
 func TestDefaultQuerierAtomicNoSavepointPanic(t *testing.T) {
 	rbErr := errors.New("rollback error")
-	expectedRbErr := atomictest.NewError(nil, rbErr)
+	expectedRbErr := satomictest.NewError(nil, rbErr)
 
 	testCases := []struct {
 		name        string
 		mocker      func(sqlmock.Sqlmock) sqlmock.Sqlmock
 		panicVal    interface{}
-		expectedErr *atomic.Error
+		expectedErr *satomic.Error
 	}{
 		{name: "rollback success", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin()
@@ -141,7 +141,7 @@ func TestDefaultQuerierAtomicNoSavepointPanic(t *testing.T) {
 			_sqlmock = tc.mocker(_sqlmock)
 
 			ctx := context.Background()
-			q, err := atomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true),
+			q, err := satomic.NewQuerier(ctx, db, mock.NewSavepointer(ioutil.Discard, true),
 				sql.TxOptions{})
 			if err != nil {
 				t.Fatal("Error creating Querier:", err)
@@ -151,13 +151,13 @@ func TestDefaultQuerierAtomicNoSavepointPanic(t *testing.T) {
 					t.Errorf("Didn't get the expected panic value: %+v != %+v", r, tc.panicVal)
 				}
 			}()
-			if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+			if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 				var dummy int
 				if err := q.QueryRowContext(ctx, "SELECT 1;").Scan(&dummy); err != nil {
 					t.Error(err)
 				}
 				panic(tc.panicVal)
-			}); !atomictest.ErrsEq(err, tc.expectedErr) {
+			}); !satomictest.ErrsEq(err, tc.expectedErr) {
 				t.Errorf("Didn't get the expected error: %+v != %+v", err, tc.expectedErr)
 			}
 
@@ -170,16 +170,16 @@ func TestDefaultQuerierAtomicNoSavepointPanic(t *testing.T) {
 
 func TestDefaultQuerierAtomicSingleSavepointReleased(t *testing.T) {
 	rbErr := errors.New("rollback error")
-	expectedRbErr := atomictest.NewError(nil, rbErr)
+	expectedRbErr := satomictest.NewError(nil, rbErr)
 
 	createErr := errors.New("savepoint error")
-	expectedCreateErr := atomictest.NewError(nil, createErr)
+	expectedCreateErr := satomictest.NewError(nil, createErr)
 
 	selectErr := errors.New("select 2 error")
-	expectedSelectErr := atomictest.NewError(selectErr, nil)
+	expectedSelectErr := satomictest.NewError(selectErr, nil)
 
 	releaseErr := errors.New("release error")
-	expectedReleaseErr := atomictest.NewError(selectErr, releaseErr)
+	expectedReleaseErr := satomictest.NewError(selectErr, releaseErr)
 
 	savepointer := func(release bool) *mock.Savepointer {
 		return mock.NewSavepointer(ioutil.Discard, release)
@@ -189,7 +189,7 @@ func TestDefaultQuerierAtomicSingleSavepointReleased(t *testing.T) {
 		name        string
 		savepointer *mock.Savepointer
 		mocker      func(sqlmock.Sqlmock) sqlmock.Sqlmock
-		expectedErr *atomic.Error
+		expectedErr *satomic.Error
 	}{
 		{name: "success", savepointer: savepointer(true), mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin()
@@ -256,19 +256,19 @@ func TestDefaultQuerierAtomicSingleSavepointReleased(t *testing.T) {
 			_sqlmock = tc.mocker(_sqlmock)
 
 			ctx := context.Background()
-			q, err := atomic.NewQuerier(ctx, db, tc.savepointer, sql.TxOptions{})
+			q, err := satomic.NewQuerier(ctx, db, tc.savepointer, sql.TxOptions{})
 			if err != nil {
 				t.Fatal("Error creating Querier:", err)
 			}
-			if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+			if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 				var dummy int
 				if err := q.QueryRowContext(ctx, "SELECT 1;").Scan(&dummy); err != nil {
 					t.Log("error in select 1:", err)
 					return err
 				}
-				if err := q.Atomic(func(ctx context.Context, q atomic.Querier) error {
+				if err := q.Atomic(func(ctx context.Context, q satomic.Querier) error {
 					return q.QueryRowContext(ctx, "SELECT 2;").Scan(&dummy)
-				}); !atomictest.ErrsEq(err, tc.expectedErr) {
+				}); !satomictest.ErrsEq(err, tc.expectedErr) {
 					t.Errorf("Didn't get the expected error: %+v != %+v", err, tc.expectedErr)
 				}
 				return nil
@@ -299,28 +299,28 @@ func TestNewQuerierWithTxCreator(t *testing.T) {
 		mocker      func(sqlmock.Sqlmock) sqlmock.Sqlmock
 		getDb       func() (*sql.DB, sqlmock.Sqlmock)
 		savepointer savepointers.Savepointer
-		txCreator   atomic.TxCreator
+		txCreator   satomic.TxCreator
 		expectedErr error
 	}{
 		{name: "nil db", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock { return m },
 			getDb: func() (*sql.DB, sqlmock.Sqlmock) {
 				_, _sqlmock := getDb()
 				return nil, _sqlmock
-			}, savepointer: mock.NewSavepointer(ioutil.Discard, true), txCreator: atomic.DefaultTxCreator,
-			expectedErr: atomic.ErrNeedsDb},
+			}, savepointer: mock.NewSavepointer(ioutil.Discard, true), txCreator: satomic.DefaultTxCreator,
+			expectedErr: satomic.ErrNeedsDb},
 		{name: "nil savepointer", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock { return m },
-			getDb: getDb, savepointer: nil, txCreator: atomic.DefaultTxCreator,
-			expectedErr: atomic.ErrNeedsSavepointer},
+			getDb: getDb, savepointer: nil, txCreator: satomic.DefaultTxCreator,
+			expectedErr: satomic.ErrNeedsSavepointer},
 		{name: "begin err", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin().WillReturnError(beginErr)
 			return m
-		}, getDb: getDb, savepointer: mock.NewSavepointer(ioutil.Discard, true), txCreator: atomic.DefaultTxCreator,
-			expectedErr: beginErr},
+		}, getDb: getDb, savepointer: mock.NewSavepointer(ioutil.Discard, true),
+			txCreator: satomic.DefaultTxCreator, expectedErr: beginErr},
 		{name: "success", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin()
 			return m
-		}, getDb: getDb, savepointer: mock.NewSavepointer(ioutil.Discard, true), txCreator: atomic.DefaultTxCreator,
-			expectedErr: nil},
+		}, getDb: getDb, savepointer: mock.NewSavepointer(ioutil.Discard, true),
+			txCreator: satomic.DefaultTxCreator, expectedErr: nil},
 		{name: "success - nil TxCreator", mocker: func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 			m.ExpectBegin()
 			return m
@@ -333,7 +333,7 @@ func TestNewQuerierWithTxCreator(t *testing.T) {
 			db, _sqlmock := tc.getDb()
 			_sqlmock = tc.mocker(_sqlmock)
 
-			if _, err := atomic.NewQuerierWithTxCreator(ctx, db, tc.savepointer,
+			if _, err := satomic.NewQuerierWithTxCreator(ctx, db, tc.savepointer,
 				sql.TxOptions{}, tc.txCreator); err != tc.expectedErr {
 				t.Errorf("Didn't get the expected error: %+v != %+v", err, tc.expectedErr)
 			}

satomictest/error.go

@@ -0,0 +1,21 @@
+package satomictest
+
+import (
+	"github.com/dhui/satomic"
+)
+
+// ErrsEq determines if the two *satomic.Errors are equal
+func ErrsEq(a, b *satomic.Error) bool {
+	if a == b {
+		return true
+	}
+	if a != nil && b != nil {
+		return *a == *b
+	}
+	return false
+}
+
+// NewError creates a new *satomic.Error
+func NewError(err, atomicErr error) *satomic.Error {
+	return &satomic.Error{Err: err, Atomic: atomicErr}
+}