testing: Introduce original suite of tests to verify ORMs

Author: nvb

Makefile

@@ -0,0 +1,30 @@
+# Copyright 2016 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License. See the AUTHORS file
+# for names of contributors.
+#
+# Author: Nathan VanBenschoten ([email protected])
+
+GO ?= go
+
+.PHONY: all
+all: test
+
+.PHONY: test
+test:
+	$(GO) test -v -i ./testing
+	$(GO) test -v ./testing
+
+.PHONY: deps
+deps:
+	$(GO) get -d -t ./...

go/gorm/Makefile

@@ -15,7 +15,11 @@
 #
 # Author: Nathan VanBenschoten ([email protected])
 
+ifneq ($(ADDR),)
+ADDRFLAG = -addr=$(ADDR)
+endif
+
 .PHONY: start
 start:
 	@go build
-	@./gorm
+	@./gorm $(ADDRFLAG)

go/gorm/main.go

@@ -1,69 +1,42 @@
 package main
 
 import (
+	"flag"
 	"log"
 	"net/http"
 
+	"github.com/cockroachdb/examples-orms/go/gorm/model"
 	"github.com/jinzhu/gorm"
 	_ "github.com/jinzhu/gorm/dialects/postgres"
 	"github.com/julienschmidt/httprouter"
 )
 
+var (
+	addr = flag.String("addr", "postgresql://root@localhost:26257/company_gorm?sslmode=disable", "the address of the database")
+)
+
 func main() {
-	db := setupDB()
+	flag.Parse()
+
+	db := setupDB(*addr)
 	defer db.Close()
 
 	router := httprouter.New()
 
 	server := NewServer(db)
 	server.RegisterRouter(router)
 
-	log.Fatal(http.ListenAndServe(":8080", router))
+	log.Fatal(http.ListenAndServe(":6543", router))
 }
 
-func setupDB() *gorm.DB {
-	db, err := gorm.Open("postgres", "postgresql://root@localhost:26257/company_gorm?sslmode=disable")
+func setupDB(addr string) *gorm.DB {
+	db, err := gorm.Open("postgres", addr)
 	if err != nil {
 		panic("failed to connect database")
 	}
 
 	// Migrate the schema
-	migrateDB(db)
-
-	// Initialize the database if it's empty.
-	var count int
-	db.Model(&Product{}).Count(&count)
-	if count == 0 {
-		// Create Products.
-		p1 := "P1"
-		p2 := "P2"
-		db.Create(&Product{Name: &p1, Price: 22.2})
-		db.Create(&Product{Name: &p2, Price: 2.2})
-
-		// Create Customers.
-		john := "John"
-		fred := "Fred"
-		db.Create(&Customer{Name: &john})
-		db.Create(&Customer{Name: &fred})
-
-		// Create an Order.
-		{
-			tx := db.Begin()
-
-			var product Product
-			tx.First(&product, "name = ?", "P2")
-
-			var customer Customer
-			tx.First(&customer, "name = ?", "Fred")
-
-			tx.Create(&Order{
-				Subtotal: product.Price,
-				Customer: customer,
-				Products: []Product{product},
-			})
-			tx.Commit()
-		}
-	}
+	db.AutoMigrate(&model.Customer{}, &model.Order{}, &model.Product{})
 
 	return db
 }

go/gorm/models.go go/gorm/model/models.gogo/gorm/models.go renamed to go/gorm/model/models.go

@@ -1,6 +1,4 @@
-package main
-
-import "github.com/jinzhu/gorm"
+package model
 
 // Customer is a model in the "customers" table.
 type Customer struct {
@@ -25,7 +23,3 @@ type Product struct {
 	Name  *string `gorm:"not null;unique"`
 	Price float64 `gorm:"type:decimal(18,2)"`
 }
-
-func migrateDB(db *gorm.DB) {
-	db.AutoMigrate(&Customer{}, &Order{}, &Product{})
-}

go/gorm/server.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/cockroachdb/examples-orms/go/gorm/model"
 	"github.com/jinzhu/gorm"
 	"github.com/julienschmidt/httprouter"
 )
@@ -42,7 +43,7 @@ func (s *Server) RegisterRouter(router *httprouter.Router) {
 }
 
 func (s *Server) getCustomers(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	var customers []Customer
+	var customers []model.Customer
 	if err := s.db.Find(&customers).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -51,7 +52,7 @@ func (s *Server) getCustomers(w http.ResponseWriter, r *http.Request, _ httprout
 }
 
 func (s *Server) createCustomer(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var customer Customer
+	var customer model.Customer
 	if err := json.NewDecoder(r.Body).Decode(&customer); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -65,7 +66,7 @@ func (s *Server) createCustomer(w http.ResponseWriter, r *http.Request, ps httpr
 }
 
 func (s *Server) getCustomer(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var customer Customer
+	var customer model.Customer
 	if err := s.db.Find(&customer, ps.ByName("customerID")).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -74,7 +75,7 @@ func (s *Server) getCustomer(w http.ResponseWriter, r *http.Request, ps httprout
 }
 
 func (s *Server) updateCustomer(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var customer Customer
+	var customer model.Customer
 	if err := json.NewDecoder(r.Body).Decode(&customer); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -90,7 +91,7 @@ func (s *Server) updateCustomer(w http.ResponseWriter, r *http.Request, ps httpr
 
 func (s *Server) deleteCustomer(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 	customerID := ps.ByName("customerID")
-	req := s.db.Delete(Customer{}, "ID = ?", customerID)
+	req := s.db.Delete(model.Customer{}, "ID = ?", customerID)
 	if err := req.Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else if req.RowsAffected == 0 {
@@ -101,7 +102,7 @@ func (s *Server) deleteCustomer(w http.ResponseWriter, r *http.Request, ps httpr
 }
 
 func (s *Server) getProducts(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	var products []Product
+	var products []model.Product
 	if err := s.db.Find(&products).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -110,7 +111,7 @@ func (s *Server) getProducts(w http.ResponseWriter, r *http.Request, _ httproute
 }
 
 func (s *Server) createProduct(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var product Product
+	var product model.Product
 	if err := json.NewDecoder(r.Body).Decode(&product); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -124,7 +125,7 @@ func (s *Server) createProduct(w http.ResponseWriter, r *http.Request, ps httpro
 }
 
 func (s *Server) getProduct(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var product Product
+	var product model.Product
 	if err := s.db.Find(&product, ps.ByName("productID")).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -133,7 +134,7 @@ func (s *Server) getProduct(w http.ResponseWriter, r *http.Request, ps httproute
 }
 
 func (s *Server) updateProduct(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var product Product
+	var product model.Product
 	if err := json.NewDecoder(r.Body).Decode(&product); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -149,7 +150,7 @@ func (s *Server) updateProduct(w http.ResponseWriter, r *http.Request, ps httpro
 
 func (s *Server) deleteProduct(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 	productID := ps.ByName("productID")
-	req := s.db.Delete(Product{}, "ID = ?", productID)
+	req := s.db.Delete(model.Product{}, "ID = ?", productID)
 	if err := req.Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else if req.RowsAffected == 0 {
@@ -160,7 +161,7 @@ func (s *Server) deleteProduct(w http.ResponseWriter, r *http.Request, ps httpro
 }
 
 func (s *Server) getOrders(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	var orders []Order
+	var orders []model.Order
 	if err := s.db.Preload("Customer").Preload("Products").Find(&orders).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -169,7 +170,7 @@ func (s *Server) getOrders(w http.ResponseWriter, r *http.Request, _ httprouter.
 }
 
 func (s *Server) createOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var order Order
+	var order model.Order
 	if err := json.NewDecoder(r.Body).Decode(&order); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -183,7 +184,7 @@ func (s *Server) createOrder(w http.ResponseWriter, r *http.Request, ps httprout
 }
 
 func (s *Server) getOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var order Order
+	var order model.Order
 	if err := s.db.Preload("Customer").Preload("Products").Find(&order, ps.ByName("orderID")).Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else {
@@ -192,7 +193,7 @@ func (s *Server) getOrder(w http.ResponseWriter, r *http.Request, ps httprouter.
 }
 
 func (s *Server) updateOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
-	var order Order
+	var order model.Order
 	if err := json.NewDecoder(r.Body).Decode(&order); err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 		return
@@ -208,7 +209,7 @@ func (s *Server) updateOrder(w http.ResponseWriter, r *http.Request, ps httprout
 
 func (s *Server) deleteOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 	orderID := ps.ByName("orderID")
-	req := s.db.Delete(Order{}, "ID = ?", orderID)
+	req := s.db.Delete(model.Order{}, "ID = ?", orderID)
 	if err := req.Error; err != nil {
 		http.Error(w, err.Error(), errToStatusCode(err))
 	} else if req.RowsAffected == 0 {
@@ -221,7 +222,7 @@ func (s *Server) deleteOrder(w http.ResponseWriter, r *http.Request, ps httprout
 func (s *Server) addProductToOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 	tx := s.db.Begin()
 
-	var order Order
+	var order model.Order
 	orderID := ps.ByName("orderID")
 	if err := tx.Preload("Products").First(&order, orderID).Error; err != nil {
 		tx.Rollback()
@@ -237,7 +238,7 @@ func (s *Server) addProductToOrder(w http.ResponseWriter, r *http.Request, ps ht
 		return
 	}
 
-	var addedProduct Product
+	var addedProduct model.Product
 	if err := tx.First(&addedProduct, productID).Error; err != nil {
 		tx.Rollback()
 		http.Error(w, err.Error(), errToStatusCode(err))

testing/api_handler.go

@@ -0,0 +1,82 @@
+package testing
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+
+	"github.com/cockroachdb/examples-orms/go/gorm/model"
+)
+
+const (
+	applicationAddr = "http://localhost:6543"
+
+	customersPath = applicationAddr + "/customer"
+	ordersPath    = applicationAddr + "/order"
+	productsPath  = applicationAddr + "/product"
+
+	jsonContentType = "application/json"
+)
+
+// apiHandler takes care of communicating with the application api. It uses GORM's models
+// for convenient JSON marshalling/unmarshalling, but this format should be the same
+// across all ORMs.
+type apiHandler struct{}
+
+func (apiHandler) queryCustomers() ([]model.Customer, error) {
+	var customers []model.Customer
+	if err := getJSON(customersPath, &customers); err != nil {
+		return nil, err
+	}
+	return cleanCustomers(customers), nil
+}
+func (apiHandler) queryProducts() ([]model.Product, error) {
+	var products []model.Product
+	if err := getJSON(productsPath, &products); err != nil {
+		return nil, err
+	}
+	return cleanProducts(products), nil
+}
+
+func (apiHandler) createCustomer(name string) error {
+	customer := model.Customer{Name: &name}
+	return postJSONData(customersPath, customer)
+}
+func (apiHandler) createProduct(name string, price float64) error {
+	product := model.Product{Name: &name, Price: price}
+	return postJSONData(productsPath, product)
+}
+
+func getJSON(path string, result interface{}) error {
+	resp, err := http.Get(path)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return json.NewDecoder(resp.Body).Decode(result)
+}
+
+func postJSONData(path string, body interface{}) error {
+	var bodyBuf bytes.Buffer
+	if err := json.NewEncoder(&bodyBuf).Encode(body); err != nil {
+		return err
+	}
+
+	_, err := http.Post(path, jsonContentType, &bodyBuf)
+	return err
+}
+
+// These functions clean any non-deterministic fields, such as IDs that are
+// generated upon row creation.
+func cleanCustomers(customers []model.Customer) []model.Customer {
+	for i := range customers {
+		customers[i].ID = 0
+	}
+	return customers
+}
+func cleanProducts(products []model.Product) []model.Product {
+	for i := range products {
+		products[i].ID = 0
+	}
+	return products
+}