Merge pull request #31 from glothriel/integration-tests-go

Integration tests are now in go

Author: glothriel

.github/workflows/k6.yaml

@@ -39,13 +39,13 @@ jobs:
         run: ./k6 run tests/k6/test.js --vus 10 --duration 30s
 
       - name: Archive k6 test result
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: k6
           path: k6.html
 
       - name: Archive system resources diagrams
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: system
           path: system.html

README.md

@@ -65,12 +65,10 @@ Other gunicorn flag variants had even lower performance.
 * SliceModelFields do not work with JSONSchemaValidator
 * Add support for model relations
 * ~~Add support for viewsets~~
-* Add support for authentication
 * Add support for complex pagination implementations
 * Add support for permissions (authorization)
 * Add support for automatic OpenAPI spec generation
-* Add support for caches
-* Add support for throttling
+
 * Add support for output formatters
 * Add support for non-JSON types
 * Add support for translations (error messages)

go.mod

@@ -4,6 +4,7 @@ go 1.21
 
 require (
 	github.com/gin-gonic/gin v1.9.1
+	github.com/go-playground/assert/v2 v2.2.0
 	github.com/go-playground/validator/v10 v10.14.1
 	github.com/google/uuid v1.3.0
 	github.com/mitchellh/mapstructure v1.5.0

pkg/detectors/internal.go

@@ -5,6 +5,7 @@ import (
 	"encoding"
 	"fmt"
 	"reflect"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/glothriel/grf/pkg/fields"
@@ -48,6 +49,28 @@ func (p *usingGRFParsableToInternalValueDetector[Model]) ToInternalValue(fieldNa
 	return nil, fmt.Errorf("Field `%s` is not a GRFParsable", fieldName)
 }
 
+type isoTimeTimeToInternalValueDetector[Model any] struct{}
+
+func (p *isoTimeTimeToInternalValueDetector[Model]) ToInternalValue(fieldName string) (fields.InternalValueFunc, error) {
+	fieldSettings := getFieldSettings[Model](fieldName)
+	if fieldSettings.itsType.Name() == "Time" && fieldSettings.itsType.PkgPath() == "time" {
+		return ConvertFuncToInternalValueFuncAdapter(
+			func(v any) (any, error) {
+				vStr, isString := v.(string)
+				if isString {
+					t, err := time.Parse(time.RFC3339, vStr)
+					if err != nil {
+						return nil, err
+					}
+					return t, nil
+				}
+				return nil, fmt.Errorf("Field `%s` is not a string", fieldName)
+			},
+		), nil
+	}
+	return nil, fmt.Errorf("Field `%s` is not a time.Time", fieldName)
+}
+
 type fromTypeMapperToInternalValueDetector[Model any] struct {
 	mapper         *types.FieldTypeMapper
 	modelTypeNames map[string]string
@@ -144,6 +167,7 @@ func DefaultToInternalValueDetector[Model any]() ToInternalValueDetector {
 			internalChild: &chainingToInternalValueDetector[Model]{
 				children: []ToInternalValueDetector{
 					&usingGRFParsableToInternalValueDetector[Model]{},
+					&isoTimeTimeToInternalValueDetector[Model]{},
 					&fromTypeMapperToInternalValueDetector[Model]{
 						mapper:         types.Mapper(),
 						modelTypeNames: FieldTypes[Model](),

pkg/examples/alltypes/main.go

@@ -32,7 +32,7 @@ type Product struct {
 
 	Name        string          `json:"name" gorm:"size:191;column:name"`
 	Description string          `json:"description" gorm:"type:text;column:description"`
-	Price       decimal.Decimal `json:"price" gorm:"type:decimal(19,4)"`
+	Price       decimal.Decimal `json:"price" gorm:"type:decimal(8,2)"`
 
 	CategoryID string   `json:"category_id" gorm:"size:191;column:category_id"`
 	Category   Category `gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;not null;"`

pkg/examples/products/main.go

@@ -0,0 +1,123 @@
+package integration
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/glothriel/grf/pkg/queries"
+	"github.com/glothriel/grf/pkg/views"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/require"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+func registerModel[Model any](
+	prefix string,
+) *gin.Engine {
+	gin.SetMode(gin.ReleaseMode)
+	router := gin.New()
+	gormDB, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		panic("failed to connect database")
+	}
+	views.NewModelViewSet[Model](prefix, queries.GORM[Model](gormDB).WithOrderBy(fmt.Sprintf("%s ASC", "created_at"))).Register(router)
+
+	var entity Model
+	if migrateErr := gormDB.AutoMigrate(&entity); migrateErr != nil {
+		logrus.Fatalf("Error migrating database: %s", migrateErr)
+	}
+	return router
+}
+
+func NewRequest(method, url string, body map[string]any) *http.Request {
+	req, _ := http.NewRequest(method, url, nil)
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+		marshalledBody, marshalErr := json.Marshal(body)
+		if marshalErr != nil {
+			panic("failed to marshal body")
+		}
+		req.Body = io.NopCloser(bytes.NewReader(marshalledBody))
+	}
+	return req
+}
+
+type TestCase struct {
+	name         string
+	t            *testing.T
+	req          *http.Request
+	expectedCode int
+	expectedJSON any
+}
+
+func (tc *TestCase) Req(r *http.Request) *TestCase {
+	tc.req = r
+	return tc
+}
+
+func (tc *TestCase) ExCode(c int) *TestCase {
+	tc.expectedCode = c
+	return tc
+}
+
+func (tc *TestCase) ExJson(j any) *TestCase {
+	tc.expectedJSON = j
+	return tc
+}
+
+func stripFields(v any, fields []string) any {
+	vMap, ok := v.(map[string]any)
+	if ok {
+		for _, field := range fields {
+			delete(vMap, field)
+		}
+		return vMap
+	}
+	vSlice, ok := v.([]any)
+	if ok {
+		for i, item := range vSlice {
+			vSlice[i] = stripFields(item, fields)
+		}
+		return vSlice
+	}
+	return v
+}
+
+func (tc *TestCase) Run(router *gin.Engine) string {
+	var theID string
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, tc.req)
+
+	tc.t.Run(tc.name, func(t *testing.T) {
+		require.Equal(t, tc.expectedCode, w.Code)
+		if tc.expectedJSON != nil {
+			var responseJSON any
+			json.Unmarshal(w.Body.Bytes(), &responseJSON)
+			rAsMap, ok := responseJSON.(map[string]any)
+			if ok {
+				id, ok := rAsMap["id"]
+				if ok {
+					theID = id.(string)
+				}
+			}
+			require.Equal(t, tc.expectedJSON, stripFields(responseJSON, []string{"id", "created_at", "updated_at"}))
+
+		}
+	})
+
+	return theID
+}
+
+func NewAssertedReq(t *testing.T, name string) *TestCase {
+	return &TestCase{
+		t:    t,
+		name: name,
+	}
+}