Feat/crud (#2)

* Upgrade go, map workflow to sqlserver primitives

* implement crud handler

Author: BSick7

.github/workflows/publish.yml

@@ -18,10 +18,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Set up Nullstone
-        uses: nullstone-io/setup-nullstone-action@v0
+        uses: actions/checkout@v5
 
       - name: Setup Go
         uses: actions/setup-go@v4
@@ -32,14 +29,15 @@ jobs:
           make build
           make package
 
+      - name: Set up Nullstone
+        uses: nullstone-io/setup-nullstone-action@v0
+
       - name: Find version
         id: version
-        run: echo "MODULE_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
+        run: echo ::set-output name=tag::${GITHUB_REF#refs/tags/v}
 
       - id: publish-aws
         name: Publish AWS
         working-directory: aws/tf
         run: |
-          nullstone modules publish \
-            --include=files/mss-db-admin.zip \
-              --version=${{ env.MODULE_VERSION }}
+          nullstone modules publish --version=${{ steps.version.outputs.tag }}

Makefile

@@ -1,25 +1,29 @@
-NAME := mss-db-admin
-
-.PHONY: tools build
-
-tools:
-	go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
-
-build:
-	mkdir -p ./aws/tf/files
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o ./aws/tf/files/bootstrap ./aws/
-
-package: tools
-	# Package aws module using build-lambda-zip which produces a viable package from any OS
-	cd ./aws/tf && build-lambda-zip --output files/mss-db-admin.zip files/bootstrap
-
-acc: acc-up acc-run acc-down
-
-acc-up:
-	cd acc && docker-compose -p mss-db-admin-acc up -d db
-
-acc-run:
-	ACC=1 gotestsum ./acc/...
-
-acc-down:
-	cd acc && docker-compose -p mss-db-admin-acc down
+NAME := mss-db-admin
+
+.PHONY: tools build
+
+tools:
+	go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
+
+build:
+	mkdir -p ./aws/tf/files
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o ./aws/tf/files/bootstrap ./aws/
+
+package: tools
+	# Package aws module using build-lambda-zip which produces a viable package from any OS
+	cd ./aws/tf && build-lambda-zip --output files/mss-db-admin.zip files/bootstrap
+
+acc: acc-up acc-wait acc-run acc-down
+
+acc-up:
+	cd acc && docker-compose -p mss-db-admin-acc up -d db
+
+acc-wait:
+	@echo "Waiting for SQL Server to start..."
+	@sleep 15
+
+acc-run:
+	ACC=1 gotestsum ./acc/...
+
+acc-down:
+	cd acc && docker-compose -p mss-db-admin-acc down

acc/compose.yml

@@ -0,0 +1,8 @@
+services:
+  db:
+    image: mcr.microsoft.com/mssql/server:2022-latest
+    ports:
+      - "1433:1433"
+    environment:
+      - ACCEPT_EULA=Y
+      - MSSQL_SA_PASSWORD=YourStr0ng!Pass

acc/database_access_test.go

@@ -0,0 +1,55 @@
+package acc
+
+import (
+	"github.com/nullstone-modules/mss-db-admin/sqlserver"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"os"
+	"testing"
+)
+
+func TestDatabaseAccess(t *testing.T) {
+	if os.Getenv("ACC") != "1" {
+		t.Skip("Set ACC=1 to run e2e tests")
+	}
+
+	store := createStore(t)
+
+	// Create database
+	_, err := store.Databases.Create(sqlserver.Database{Name: "access-test-db"})
+	require.NoError(t, err, "create database")
+
+	// Create login
+	_, err = store.Logins.Create(sqlserver.Login{
+		Name:     "access-test-user",
+		Password: "Acc3ss!TestPass",
+	})
+	require.NoError(t, err, "create login")
+
+	// Grant access
+	access := sqlserver.DatabaseAccess{
+		Database: "access-test-db",
+		Login:    "access-test-user",
+	}
+	result, err := store.DatabaseAccess.Create(access)
+	require.NoError(t, err, "grant database access")
+	require.NotNil(t, result)
+	assert.Equal(t, "access-test-db", result.Database)
+	assert.Equal(t, "access-test-user", result.Login)
+
+	// Read access
+	found, err := store.DatabaseAccess.Read(sqlserver.DatabaseAccessKey{
+		Database: "access-test-db",
+		Login:    "access-test-user",
+	})
+	require.NoError(t, err, "read database access")
+	require.NotNil(t, found)
+
+	// Revoke access
+	ok, err := store.DatabaseAccess.Drop(sqlserver.DatabaseAccessKey{
+		Database: "access-test-db",
+		Login:    "access-test-user",
+	})
+	require.NoError(t, err, "revoke database access")
+	assert.True(t, ok)
+}

acc/database_test.go

@@ -1,34 +1,29 @@
 package acc
 
 import (
-	_ "github.com/lib/pq"
+	"os"
+	"testing"
+
 	"github.com/nullstone-modules/mss-db-admin/sqlserver"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"os"
-	"testing"
 )
 
 func TestDatabase(t *testing.T) {
 	if os.Getenv("ACC") != "1" {
 		t.Skip("Set ACC=1 to run e2e tests")
 	}
 
-	db := createDb(t)
-	defer db.Close()
-
-	database := sqlserver.Database{Name: "database-test-database"}
-
-	ownerRole := sqlserver.Role{Name: database.Name}
-	require.NoError(t, ownerRole.Ensure(db), "error creating owner role")
-	database.Owner = ownerRole.Name
-
-	dbInfo, err := sqlserver.CalcDbConnectionInfo(db)
-	require.NoError(t, err, "calc db info")
+	store := createStore(t)
 
-	require.NoError(t, database.Create(db, *dbInfo), "unexpected error")
+	database := sqlserver.Database{Name: "database-test-db"}
+	result, err := store.Databases.Create(database)
+	require.NoError(t, err, "create database")
+	require.NotNil(t, result)
+	assert.Equal(t, "database-test-db", result.Name)
 
-	find := &sqlserver.Database{Name: "database-test-database"}
-	require.NoError(t, find.Read(db), "read database")
-	assert.Equal(t, ownerRole.Name, find.Owner, "mismatched owner")
+	found, err := store.Databases.Read("database-test-db")
+	require.NoError(t, err, "read database")
+	require.NotNil(t, found)
+	assert.Equal(t, "database-test-db", found.Name)
 }

acc/db.go

@@ -1,15 +1,16 @@
 package acc
 
 import (
-	"database/sql"
+	"github.com/nullstone-modules/mss-db-admin/sqlserver"
 	"testing"
+
+	_ "github.com/microsoft/go-mssqldb"
 )
 
-func createDb(t *testing.T) *sql.DB {
-	connUrl := "postgres://pda:pda@localhost:8432/postgres?sslmode=disable"
-	db, err := sql.Open("postgres", connUrl)
-	if err != nil {
-		t.Fatalf("error connecting to postgres: %s", err)
-	}
-	return db
+const connUrl = "sqlserver://sa:YourStr0ng!Pass@localhost:1433?database=master"
+
+func createStore(t *testing.T) *sqlserver.Store {
+	store := sqlserver.NewStore(connUrl)
+	t.Cleanup(func() { store.Close() })
+	return store
 }

acc/docker-compose.yml

@@ -1,71 +1,68 @@
 package acc
 
 import (
-	"database/sql"
 	"fmt"
-	_ "github.com/lib/pq"
+	_ "github.com/microsoft/go-mssqldb"
 	"github.com/nullstone-modules/mss-db-admin/sqlserver"
-	"github.com/nullstone-modules/mss-db-admin/workflows"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"net/url"
 	"os"
 	"strings"
 	"testing"
-	"time"
 )
 
-// TestFull tests the entire workflow of create-database, create-user, create-db-access
+// TestFull tests the entire CRUD workflow:
+// create database -> create login -> grant access -> connect as user -> create table -> insert -> query
 func TestFull(t *testing.T) {
 	if os.Getenv("ACC") != "1" {
 		t.Skip("Set ACC=1 to run e2e tests")
 	}
 
-	connUrl := "postgres://pda:pda@localhost:8432/postgres?sslmode=disable"
-	db, err := sql.Open("postgres", connUrl)
-	require.NoError(t, err, "connecting to postgres")
-	defer db.Close()
-	appConnUrl := "postgres://test-user:test-password@localhost:8432/test-database?sslmode=disable"
-	appDb, err := sql.Open("postgres", appConnUrl)
-	defer appDb.Close()
-	fmt.Println(appDb.Ping())
+	store := createStore(t)
 
-	newDatabase := sqlserver.Database{
-		Name:  "test-database",
-		Owner: "test-database",
-	}
-	newUser := sqlserver.Role{
-		Name:     "test-user",
-		Password: "test-password",
-	}
+	dbName := "full-test-db"
+	loginName := "full-test-user"
+	loginPass := "Full!Test0Pass"
+
+	// Create the database
+	_, err := store.Databases.Create(sqlserver.Database{Name: dbName})
+	require.NoError(t, err, "create database")
 
-	require.NoError(t, workflows.EnsureDatabase(db, newDatabase), "ensure database")
-	require.NoError(t, workflows.EnsureUser(db, newUser), "ensure user")
-	require.NoError(t, workflows.GrantDbAccess(db, appDb, newUser, newDatabase), "grant db access")
+	// Create the login
+	_, err = store.Logins.Create(sqlserver.Login{Name: loginName, Password: loginPass})
+	require.NoError(t, err, "create login")
 
-	time.Sleep(500 * time.Millisecond)
+	// Grant access
+	_, err = store.DatabaseAccess.Create(sqlserver.DatabaseAccess{Database: dbName, Login: loginName})
+	require.NoError(t, err, "grant database access")
 
-	// Attempt connection to newly-created app db
-	u, _ := url.Parse(connUrl)
-	u.Path = "/test-database"
-	u.User = url.UserPassword(newUser.Name, newUser.Password)
+	// Connect as the new user to the app database
+	userConnUrl := fmt.Sprintf("sqlserver://%s:%s@localhost:1433?database=%s",
+		url.PathEscape(loginName),
+		url.PathEscape(loginPass),
+		url.PathEscape(dbName),
+	)
+	userDb, err := sqlserver.OpenDatabase(userConnUrl, "")
+	require.NoError(t, err, "connecting as app user")
+	defer userDb.Close()
 
-	// Attempt to create schema objects
-	_, err = appDb.Exec("CREATE TABLE todos ( id SERIAL NOT NULL, name varchar(255) );")
+	// Create a table
+	_, err = userDb.Exec("CREATE TABLE todos ( id INT IDENTITY(1,1) NOT NULL, name varchar(255) );")
 	require.NoError(t, err, "create table")
 
-	// Attempt to insert records
+	// Insert records
 	sq := strings.Join([]string{
 		`INSERT INTO todos (name) VALUES ('item1');`,
 		`INSERT INTO todos (name) VALUES ('item2');`,
 		`INSERT INTO todos (name) VALUES ('item3');`,
-	}, "")
-	_, err = appDb.Exec(sq)
+	}, " ")
+	_, err = userDb.Exec(sq)
 	require.NoError(t, err, "insert todos")
 
-	// Attempt to retrieve them
+	// Query records
 	results := make([]string, 0)
-	rows, err := appDb.Query(`SELECT * FROM todos`)
+	rows, err := userDb.Query(`SELECT id, name FROM todos ORDER BY id`)
 	require.NoError(t, err, "query todos")
 	defer rows.Close()
 	for rows.Next() {

acc/full_test.go

@@ -0,0 +1,38 @@
+package acc
+
+import (
+	"github.com/nullstone-modules/mss-db-admin/sqlserver"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"os"
+	"testing"
+)
+
+func TestLogin(t *testing.T) {
+	if os.Getenv("ACC") != "1" {
+		t.Skip("Set ACC=1 to run e2e tests")
+	}
+
+	store := createStore(t)
+
+	login := sqlserver.Login{
+		Name:     "login-test-user",
+		Password: "L0gin!TestPass",
+	}
+	result, err := store.Logins.Create(login)
+	require.NoError(t, err, "create login")
+	require.NotNil(t, result)
+	assert.Equal(t, "login-test-user", result.Name)
+
+	found, err := store.Logins.Read("login-test-user")
+	require.NoError(t, err, "read login")
+	require.NotNil(t, found)
+	assert.Equal(t, "login-test-user", found.Name)
+
+	updated, err := store.Logins.Update("login-test-user", sqlserver.Login{
+		Name:     "login-test-user",
+		Password: "NewL0gin!Pass",
+	})
+	require.NoError(t, err, "update login password")
+	require.NotNil(t, updated)
+}