diff --git a/tests/admin_test.go b/tests/admin_test.go
index c62676e..3199e2b 100644
--- a/tests/admin_test.go
+++ b/tests/admin_test.go
@@ -1,65 +1,117 @@
 package tests
 
 import (
-  "database/sql"
   "testing"
   "fmt"
   "reflect"
-  "log"
   "zedshaw.games/webapp/data"
   _ "github.com/mattn/go-sqlite3"
   sq "github.com/Masterminds/squirrel"
 )
 
-func SelectTable1(table string, theType reflect.Type, err error, sql_query string, args ...interface{}) (error) {
-  db, err := sql.Open("sqlite3", "./db.sqlite3")
-  defer db.Close()
+func SelectTable(table string, the_type reflect.Type) ([]reflect.Value, error) {
+  var results []reflect.Value
+  sql_query, args, err := sq.Select("*").From(table).ToSql()
+  if err != nil { return results, err }
 
-  rows, err := db.Query(sql_query, args...)
-  if err != nil { log.Fatal(err) }
+  rows, err := data.DB.Queryx(sql_query, args...)
+  if err != nil { return results, err }
   defer rows.Close()
 
   for rows.Next() {
-    data := make([]interface{}, theType.NumField())
-    columns := make([]interface{}, theType.NumField())
+    the_data := reflect.New(the_type)
+    err = rows.StructScan(the_data.Interface())
+    if err != nil { return results, err }
 
-    for i := 0; i < len(columns); i++ {
-      columns[i] = &data[i]
-    }
+    results = append(results, the_data.Elem())
+  }
 
-    rows.Scan(columns...)
+  return results, rows.Err()
+}
 
-    fmt.Println(data)
-  }
+func Get(table string, the_type reflect.Type, id int64) (reflect.Value, error) {
+  sql_query, args, err := sq.Select("*").From(table).Where("id", id).ToSql()
+  if err != nil { return reflect.New(nil), err }
 
-  return rows.Err()
+  the_data := reflect.New(the_type)
+  err = data.DB.Get(the_data.Interface(), sql_query, args...)
+
+  // BUG: not sure if Elem or returning the reflect.New is better
+  return the_data.Elem(), err
 }
 
-func SelectTable2(theType reflect.Type, err error, sql_query string, args ...interface{}) (error) {
+func Delete(table string, id int64) error {
+  sql_query, args, err := sq.Delete(table).Where("id", id).ToSql()
+  if err != nil { return err }
 
-  the_data := reflect.New(theType)
+  _, err = data.DB.Exec(sql_query, args...)
+  return err
+}
 
-  err = data.DB.Get(the_data.Interface(), sql_query, args...)
+func Update(table string, value reflect.Value) error {
+  builder := sq.Update(table)
+
+  type_of := value.Type()
+  field_num := value.NumField()
+  fmt.Printf("value has %d fields", field_num)
+
+  for i := 0; i < field_num; i++ {
+    field := value.Field(i)
+    tag := type_of.Field(i).Tag.Get("db")
+
+    // skip update of id to avoid replacing it
+    if tag == "id" { continue }
+
+    fmt.Printf("\nset %v to %v", tag, field.Interface())
+    builder = builder.Set(tag, field.Interface())
+  }
 
-  fmt.Println("select after says", the_data)
+  builder.Where("id", value.FieldByName("Id").Interface())
+
+  sql_query, args, err := builder.ToSql()
+
+  fmt.Println("SQL: sql_query", sql_query, args, err)
+
+  _, err = data.DB.Exec(sql_query, args...)
 
   return err
 }
 
 func TestAdminIndexPage(t *testing.T) {
-
   models := data.Models()
+  table := "user"
+  model := models[table]
 
-  for table, model := range models {
-    fmt.Printf("\n------\ntable=%s; model=%s\n", table, model.Name())
-    fields := reflect.VisibleFields(model)
-
-    for _, field := range fields {
-      fmt.Println("\t", field.Name, field.Type, field.Tag)
-    }
+  fmt.Printf("\n------\ntable=%s; model=%s\n", table, model.Name())
+  fields := reflect.VisibleFields(model)
 
-    sql, args, err := sq.Select("*").From(table).ToSql()
-    err = SelectTable2(model, err, sql, args...)
-    if err != nil { fmt.Println("ERROR", err) }
+  for _, field := range fields {
+    fmt.Println("\t", field.Name, field.Type, field.Tag)
   }
+
+  all_rows, err := SelectTable(table, model)
+  if err != nil { fmt.Println("ERROR", err) }
+  first_row := all_rows[0]
+
+  result, err := Get(table, model, first_row.FieldByName("Id").Int())
+  if err != nil { fmt.Println("ERROR", err) }
+  fmt.Println("TABLE: ", result)
+
+  id := result.FieldByName("Id")
+  result, err = Get(table, model, id.Int())
+  if err != nil { fmt.Println("ERROR", err) }
+  fmt.Println("GET: ", result)
+
+  username := result.FieldByName("Username")
+
+  username.SetString("joeblow")
+  err = Update(table, result)
+  if err != nil { fmt.Println("ERROR", err) }
+
+  username.SetString("zedshaw")
+  err = Update(table, result)
+  if err != nil { fmt.Println("ERROR", err) }
+
+  // err = Delete(table, id.Int())
+  // if err != nil { fmt.Println("ERROR", err) }
 }