OpenAI: Simplify input output in testing (#5858)

* simplify input output

* direct comp

* in line image

* rm error pointer type

* update response testing

* lint

openai/openai_test.go

@@ -7,27 +7,22 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"reflect"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/gin-gonic/gin"
-	"github.com/stretchr/testify/assert"
 
 	"github.com/ollama/ollama/api"
 )
 
 const (
-	prefix   = `data:image/jpeg;base64,`
+	prefix = `data:image/jpeg;base64,`
-	image    = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
+	image  = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
-	imageURL = prefix + image
 )
 
-func prepareRequest(req *http.Request, body any) {
+var False = false
-	bodyBytes, _ := json.Marshal(body)
-	req.Body = io.NopCloser(bytes.NewReader(bodyBytes))
-	req.Header.Set("Content-Type", "application/json")
-}
 
 func captureRequestMiddleware(capturedRequest any) gin.HandlerFunc {
 	return func(c *gin.Context) {
@@ -43,134 +38,136 @@ func captureRequestMiddleware(capturedRequest any) gin.HandlerFunc {
 
 func TestChatMiddleware(t *testing.T) {
 	type testCase struct {
-		Name     string
+		name string
-		Setup    func(t *testing.T, req *http.Request)
+		body string
-		Expected func(t *testing.T, req *api.ChatRequest, resp *httptest.ResponseRecorder)
+		req  api.ChatRequest
+		err  ErrorResponse
 	}
 
 	var capturedRequest *api.ChatRequest
 
 	testCases := []testCase{
 		{
-			Name: "chat handler",
+			name: "chat handler",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := ChatCompletionRequest{
+				"model": "test-model",
-					Model:    "test-model",
+				"messages": [
-					Messages: []Message{{Role: "user", Content: "Hello"}},
+					{"role": "user", "content": "Hello"}
-				}
+				]
-				prepareRequest(req, body)
+			}`,
-			},
+			req: api.ChatRequest{
-			Expected: func(t *testing.T, req *api.ChatRequest, resp *httptest.ResponseRecorder) {
+				Model: "test-model",
-				if resp.Code != http.StatusOK {
+				Messages: []api.Message{
-					t.Fatalf("expected 200, got %d", resp.Code)
+					{
-				}
+						Role:    "user",
-
+						Content: "Hello",
-				if req.Messages[0].Role != "user" {
+					},
-					t.Fatalf("expected 'user', got %s", req.Messages[0].Role)
+				},
-				}
+				Options: map[string]any{
-
+					"temperature": 1.0,
-				if req.Messages[0].Content != "Hello" {
+					"top_p":       1.0,
-					t.Fatalf("expected 'Hello', got %s", req.Messages[0].Content)
+				},
-				}
+				Stream: &False,
 			},
 		},
 		{
-			Name: "chat handler with image content",
+			name: "chat handler with image content",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := ChatCompletionRequest{
+				"model": "test-model",
-					Model: "test-model",
+				"messages": [
-					Messages: []Message{
+					{
-						{
+						"role": "user",
-							Role: "user", Content: []map[string]any{
+						"content": [
-								{"type": "text", "text": "Hello"},
+							{
-								{"type": "image_url", "image_url": map[string]string{"url": imageURL}},
+								"type": "text",
+								"text": "Hello"
+							},
+							{
+								"type": "image_url",
+								"image_url": {
+									"url": "` + prefix + image + `"
+								}
+							}
+						]
+					}
+				]
+			}`,
+			req: api.ChatRequest{
+				Model: "test-model",
+				Messages: []api.Message{
+					{
+						Role:    "user",
+						Content: "Hello",
+					},
+					{
+						Role: "user",
+						Images: []api.ImageData{
+							func() []byte {
+								img, _ := base64.StdEncoding.DecodeString(image)
+								return img
+							}(),
+						},
+					},
+				},
+				Options: map[string]any{
+					"temperature": 1.0,
+					"top_p":       1.0,
+				},
+				Stream: &False,
+			},
+		},
+		{
+			name: "chat handler with tools",
+			body: `{
+				"model": "test-model",
+				"messages": [
+					{"role": "user", "content": "What's the weather like in Paris Today?"},
+					{"role": "assistant", "tool_calls": [{"id": "id", "type": "function", "function": {"name": "get_current_weather", "arguments": "{\"location\": \"Paris, France\", \"format\": \"celsius\"}"}}]}
+				]
+			}`,
+			req: api.ChatRequest{
+				Model: "test-model",
+				Messages: []api.Message{
+					{
+						Role:    "user",
+						Content: "What's the weather like in Paris Today?",
+					},
+					{
+						Role: "assistant",
+						ToolCalls: []api.ToolCall{
+							{
+								Function: api.ToolCallFunction{
+									Name: "get_current_weather",
+									Arguments: map[string]interface{}{
+										"location": "Paris, France",
+										"format":   "celsius",
+									},
+								},
 							},
 						},
 					},
-				}
+				},
-				prepareRequest(req, body)
+				Options: map[string]any{
-			},
+					"temperature": 1.0,
-			Expected: func(t *testing.T, req *api.ChatRequest, resp *httptest.ResponseRecorder) {
+					"top_p":       1.0,
-				if resp.Code != http.StatusOK {
+				},
-					t.Fatalf("expected 200, got %d", resp.Code)
+				Stream: &False,
-				}
-
-				if req.Messages[0].Role != "user" {
-					t.Fatalf("expected 'user', got %s", req.Messages[0].Role)
-				}
-
-				if req.Messages[0].Content != "Hello" {
-					t.Fatalf("expected 'Hello', got %s", req.Messages[0].Content)
-				}
-
-				img, _ := base64.StdEncoding.DecodeString(imageURL[len(prefix):])
-
-				if req.Messages[1].Role != "user" {
-					t.Fatalf("expected 'user', got %s", req.Messages[1].Role)
-				}
-
-				if !bytes.Equal(req.Messages[1].Images[0], img) {
-					t.Fatalf("expected image encoding, got %s", req.Messages[1].Images[0])
-				}
 			},
 		},
+
 		{
-			Name: "chat handler with tools",
+			name: "chat handler error forwarding",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := ChatCompletionRequest{
+				"model": "test-model",
-					Model: "test-model",
+				"messages": [
-					Messages: []Message{
+					{"role": "user", "content": 2}
-						{Role: "user", Content: "What's the weather like in Paris Today?"},
+				]
-						{Role: "assistant", ToolCalls: []ToolCall{{
+			}`,
-							ID:   "id",
+			err: ErrorResponse{
-							Type: "function",
+				Error: Error{
-							Function: struct {
+					Message: "invalid message content type: float64",
-								Name      string `json:"name"`
+					Type:    "invalid_request_error",
-								Arguments string `json:"arguments"`
+				},
-							}{
-								Name:      "get_current_weather",
-								Arguments: "{\"location\": \"Paris, France\", \"format\": \"celsius\"}",
-							},
-						}}},
-					},
-				}
-				prepareRequest(req, body)
-			},
-			Expected: func(t *testing.T, req *api.ChatRequest, resp *httptest.ResponseRecorder) {
-				if resp.Code != 200 {
-					t.Fatalf("expected 200, got %d", resp.Code)
-				}
-
-				if req.Messages[0].Content != "What's the weather like in Paris Today?" {
-					t.Fatalf("expected What's the weather like in Paris Today?, got %s", req.Messages[0].Content)
-				}
-
-				if req.Messages[1].ToolCalls[0].Function.Arguments["location"] != "Paris, France" {
-					t.Fatalf("expected 'Paris, France', got %v", req.Messages[1].ToolCalls[0].Function.Arguments["location"])
-				}
-
-				if req.Messages[1].ToolCalls[0].Function.Arguments["format"] != "celsius" {
-					t.Fatalf("expected celsius, got %v", req.Messages[1].ToolCalls[0].Function.Arguments["format"])
-				}
-			},
-		},
-		{
-			Name: "chat handler error forwarding",
-			Setup: func(t *testing.T, req *http.Request) {
-				body := ChatCompletionRequest{
-					Model:    "test-model",
-					Messages: []Message{{Role: "user", Content: 2}},
-				}
-				prepareRequest(req, body)
-			},
-			Expected: func(t *testing.T, req *api.ChatRequest, resp *httptest.ResponseRecorder) {
-				if resp.Code != http.StatusBadRequest {
-					t.Fatalf("expected 400, got %d", resp.Code)
-				}
-
-				if !strings.Contains(resp.Body.String(), "invalid message content type") {
-					t.Fatalf("error was not forwarded")
-				}
 			},
 		},
 	}
@@ -185,16 +182,26 @@ func TestChatMiddleware(t *testing.T) {
 	router.Handle(http.MethodPost, "/api/chat", endpoint)
 
 	for _, tc := range testCases {
-		t.Run(tc.Name, func(t *testing.T) {
+		t.Run(tc.name, func(t *testing.T) {
-			req, _ := http.NewRequest(http.MethodPost, "/api/chat", nil)
+			req, _ := http.NewRequest(http.MethodPost, "/api/chat", strings.NewReader(tc.body))
-
+			req.Header.Set("Content-Type", "application/json")
-			tc.Setup(t, req)
 
 			resp := httptest.NewRecorder()
 			router.ServeHTTP(resp, req)
 
-			tc.Expected(t, capturedRequest, resp)
+			var errResp ErrorResponse
+			if resp.Code != http.StatusOK {
+				if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if capturedRequest != nil && !reflect.DeepEqual(tc.req, *capturedRequest) {
+				t.Fatal("requests did not match")
+			}
 
+			if !reflect.DeepEqual(tc.err, errResp) {
+				t.Fatal("errors did not match")
+			}
 			capturedRequest = nil
 		})
 	}
@@ -202,71 +209,52 @@ func TestChatMiddleware(t *testing.T) {
 
 func TestCompletionsMiddleware(t *testing.T) {
 	type testCase struct {
-		Name     string
+		name string
-		Setup    func(t *testing.T, req *http.Request)
+		body string
-		Expected func(t *testing.T, req *api.GenerateRequest, resp *httptest.ResponseRecorder)
+		req  api.GenerateRequest
+		err  ErrorResponse
 	}
 
 	var capturedRequest *api.GenerateRequest
 
 	testCases := []testCase{
 		{
-			Name: "completions handler",
+			name: "completions handler",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				temp := float32(0.8)
+				"model": "test-model",
-				body := CompletionRequest{
+				"prompt": "Hello",
-					Model:       "test-model",
+				"temperature": 0.8,
-					Prompt:      "Hello",
+				"stop": ["\n", "stop"],
-					Temperature: &temp,
+				"suffix": "suffix"
-					Stop:        []string{"\n", "stop"},
+			}`,
-					Suffix:      "suffix",
+			req: api.GenerateRequest{
-				}
+				Model:  "test-model",
-				prepareRequest(req, body)
+				Prompt: "Hello",
-			},
+				Options: map[string]any{
-			Expected: func(t *testing.T, req *api.GenerateRequest, resp *httptest.ResponseRecorder) {
+					"frequency_penalty": 0.0,
-				if req.Prompt != "Hello" {
+					"presence_penalty":  0.0,
-					t.Fatalf("expected 'Hello', got %s", req.Prompt)
+					"temperature":       1.6,
-				}
+					"top_p":             1.0,
-
+					"stop":              []any{"\n", "stop"},
-				if req.Options["temperature"] != 1.6 {
+				},
-					t.Fatalf("expected 1.6, got %f", req.Options["temperature"])
+				Suffix: "suffix",
-				}
+				Stream: &False,
-
-				stopTokens, ok := req.Options["stop"].([]any)
-
-				if !ok {
-					t.Fatalf("expected stop tokens to be a list")
-				}
-
-				if stopTokens[0] != "\n" || stopTokens[1] != "stop" {
-					t.Fatalf("expected ['\\n', 'stop'], got %v", stopTokens)
-				}
-
-				if req.Suffix != "suffix" {
-					t.Fatalf("expected 'suffix', got %s", req.Suffix)
-				}
 			},
 		},
 		{
-			Name: "completions handler error forwarding",
+			name: "completions handler error forwarding",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := CompletionRequest{
+				"model": "test-model",
-					Model:       "test-model",
+				"prompt": "Hello",
-					Prompt:      "Hello",
+				"temperature": null,
-					Temperature: nil,
+				"stop": [1, 2],
-					Stop:        []int{1, 2},
+				"suffix": "suffix"
-					Suffix:      "suffix",
+			}`,
-				}
+			err: ErrorResponse{
-				prepareRequest(req, body)
+				Error: Error{
-			},
+					Message: "invalid type for 'stop' field: float64",
-			Expected: func(t *testing.T, req *api.GenerateRequest, resp *httptest.ResponseRecorder) {
+					Type:    "invalid_request_error",
-				if resp.Code != http.StatusBadRequest {
+				},
-					t.Fatalf("expected 400, got %d", resp.Code)
-				}
-
-				if !strings.Contains(resp.Body.String(), "invalid type for 'stop' field") {
-					t.Fatalf("error was not forwarded")
-				}
 			},
 		},
 	}
@@ -281,15 +269,27 @@ func TestCompletionsMiddleware(t *testing.T) {
 	router.Handle(http.MethodPost, "/api/generate", endpoint)
 
 	for _, tc := range testCases {
-		t.Run(tc.Name, func(t *testing.T) {
+		t.Run(tc.name, func(t *testing.T) {
-			req, _ := http.NewRequest(http.MethodPost, "/api/generate", nil)
+			req, _ := http.NewRequest(http.MethodPost, "/api/generate", strings.NewReader(tc.body))
-
+			req.Header.Set("Content-Type", "application/json")
-			tc.Setup(t, req)
 
 			resp := httptest.NewRecorder()
 			router.ServeHTTP(resp, req)
 
-			tc.Expected(t, capturedRequest, resp)
+			var errResp ErrorResponse
+			if resp.Code != http.StatusOK {
+				if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if capturedRequest != nil && !reflect.DeepEqual(tc.req, *capturedRequest) {
+				t.Fatal("requests did not match")
+			}
+
+			if !reflect.DeepEqual(tc.err, errResp) {
+				t.Fatal("errors did not match")
+			}
 
 			capturedRequest = nil
 		})
@@ -298,78 +298,47 @@ func TestCompletionsMiddleware(t *testing.T) {
 
 func TestEmbeddingsMiddleware(t *testing.T) {
 	type testCase struct {
-		Name     string
+		name string
-		Setup    func(t *testing.T, req *http.Request)
+		body string
-		Expected func(t *testing.T, req *api.EmbedRequest, resp *httptest.ResponseRecorder)
+		req  api.EmbedRequest
+		err  ErrorResponse
 	}
 
 	var capturedRequest *api.EmbedRequest
 
 	testCases := []testCase{
 		{
-			Name: "embed handler single input",
+			name: "embed handler single input",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := EmbedRequest{
+				"input": "Hello",
-					Input: "Hello",
+				"model": "test-model"
-					Model: "test-model",
+			}`,
-				}
+			req: api.EmbedRequest{
-				prepareRequest(req, body)
+				Input: "Hello",
-			},
+				Model: "test-model",
-			Expected: func(t *testing.T, req *api.EmbedRequest, resp *httptest.ResponseRecorder) {
-				if req.Input != "Hello" {
-					t.Fatalf("expected 'Hello', got %s", req.Input)
-				}
-
-				if req.Model != "test-model" {
-					t.Fatalf("expected 'test-model', got %s", req.Model)
-				}
 			},
 		},
 		{
-			Name: "embed handler batch input",
+			name: "embed handler batch input",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := EmbedRequest{
+				"input": ["Hello", "World"],
-					Input: []string{"Hello", "World"},
+				"model": "test-model"
-					Model: "test-model",
+			}`,
-				}
+			req: api.EmbedRequest{
-				prepareRequest(req, body)
+				Input: []any{"Hello", "World"},
-			},
+				Model: "test-model",
-			Expected: func(t *testing.T, req *api.EmbedRequest, resp *httptest.ResponseRecorder) {
-				input, ok := req.Input.([]any)
-
-				if !ok {
-					t.Fatalf("expected input to be a list")
-				}
-
-				if input[0].(string) != "Hello" {
-					t.Fatalf("expected 'Hello', got %s", input[0])
-				}
-
-				if input[1].(string) != "World" {
-					t.Fatalf("expected 'World', got %s", input[1])
-				}
-
-				if req.Model != "test-model" {
-					t.Fatalf("expected 'test-model', got %s", req.Model)
-				}
 			},
 		},
 		{
-			Name: "embed handler error forwarding",
+			name: "embed handler error forwarding",
-			Setup: func(t *testing.T, req *http.Request) {
+			body: `{
-				body := EmbedRequest{
+				"model": "test-model"
-					Model: "test-model",
+			}`,
-				}
+			err: ErrorResponse{
-				prepareRequest(req, body)
+				Error: Error{
-			},
+					Message: "invalid input",
-			Expected: func(t *testing.T, req *api.EmbedRequest, resp *httptest.ResponseRecorder) {
+					Type:    "invalid_request_error",
-				if resp.Code != http.StatusBadRequest {
+				},
-					t.Fatalf("expected 400, got %d", resp.Code)
-				}
-
-				if !strings.Contains(resp.Body.String(), "invalid input") {
-					t.Fatalf("error was not forwarded")
-				}
 			},
 		},
 	}
@@ -384,116 +353,167 @@ func TestEmbeddingsMiddleware(t *testing.T) {
 	router.Handle(http.MethodPost, "/api/embed", endpoint)
 
 	for _, tc := range testCases {
-		t.Run(tc.Name, func(t *testing.T) {
+		t.Run(tc.name, func(t *testing.T) {
-			req, _ := http.NewRequest(http.MethodPost, "/api/embed", nil)
+			req, _ := http.NewRequest(http.MethodPost, "/api/embed", strings.NewReader(tc.body))
-
+			req.Header.Set("Content-Type", "application/json")
-			tc.Setup(t, req)
 
 			resp := httptest.NewRecorder()
 			router.ServeHTTP(resp, req)
 
-			tc.Expected(t, capturedRequest, resp)
+			var errResp ErrorResponse
+			if resp.Code != http.StatusOK {
+				if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if capturedRequest != nil && !reflect.DeepEqual(tc.req, *capturedRequest) {
+				t.Fatal("requests did not match")
+			}
+
+			if !reflect.DeepEqual(tc.err, errResp) {
+				t.Fatal("errors did not match")
+			}
 
 			capturedRequest = nil
 		})
 	}
 }
 
-func TestMiddlewareResponses(t *testing.T) {
+func TestListMiddleware(t *testing.T) {
 	type testCase struct {
-		Name     string
+		name     string
-		Method   string
+		endpoint func(c *gin.Context)
-		Path     string
+		resp     string
-		TestPath string
-		Handler  func() gin.HandlerFunc
-		Endpoint func(c *gin.Context)
-		Setup    func(t *testing.T, req *http.Request)
-		Expected func(t *testing.T, resp *httptest.ResponseRecorder)
 	}
 
 	testCases := []testCase{
 		{
-			Name:     "list handler",
+			name: "list handler",
-			Method:   http.MethodGet,
+			endpoint: func(c *gin.Context) {
-			Path:     "/api/tags",
-			TestPath: "/api/tags",
-			Handler:  ListMiddleware,
-			Endpoint: func(c *gin.Context) {
 				c.JSON(http.StatusOK, api.ListResponse{
 					Models: []api.ListModelResponse{
 						{
-							Name: "Test Model",
+							Name:       "test-model",
+							ModifiedAt: time.Unix(int64(1686935002), 0).UTC(),
 						},
 					},
 				})
 			},
-			Expected: func(t *testing.T, resp *httptest.ResponseRecorder) {
+			resp: `{
-				var listResp ListCompletion
+				"object": "list",
-				if err := json.NewDecoder(resp.Body).Decode(&listResp); err != nil {
+				"data": [
-					t.Fatal(err)
+					{
-				}
+						"id": "test-model",
-
+						"object": "model",
-				if listResp.Object != "list" {
+						"created": 1686935002,
-					t.Fatalf("expected list, got %s", listResp.Object)
+						"owned_by": "library"
-				}
+					}
-
+				]
-				if len(listResp.Data) != 1 {
+			}`,
-					t.Fatalf("expected 1, got %d", len(listResp.Data))
-				}
-
-				if listResp.Data[0].Id != "Test Model" {
-					t.Fatalf("expected Test Model, got %s", listResp.Data[0].Id)
-				}
-			},
 		},
 		{
-			Name:     "retrieve model",
+			name: "list handler empty output",
-			Method:   http.MethodGet,
+			endpoint: func(c *gin.Context) {
-			Path:     "/api/show/:model",
+				c.JSON(http.StatusOK, api.ListResponse{})
-			TestPath: "/api/show/test-model",
-			Handler:  RetrieveMiddleware,
-			Endpoint: func(c *gin.Context) {
-				c.JSON(http.StatusOK, api.ShowResponse{
-					ModifiedAt: time.Date(2024, 6, 17, 13, 45, 0, 0, time.UTC),
-				})
-			},
-			Expected: func(t *testing.T, resp *httptest.ResponseRecorder) {
-				var retrieveResp Model
-				if err := json.NewDecoder(resp.Body).Decode(&retrieveResp); err != nil {
-					t.Fatal(err)
-				}
-
-				if retrieveResp.Object != "model" {
-					t.Fatalf("Expected object to be model, got %s", retrieveResp.Object)
-				}
-
-				if retrieveResp.Id != "test-model" {
-					t.Fatalf("Expected id to be test-model, got %s", retrieveResp.Id)
-				}
 			},
+			resp: `{
+				"object": "list",
+				"data": null
+			}`,
 		},
 	}
 
 	gin.SetMode(gin.TestMode)
-	router := gin.New()
 
 	for _, tc := range testCases {
-		t.Run(tc.Name, func(t *testing.T) {
+		router := gin.New()
-			router = gin.New()
+		router.Use(ListMiddleware())
-			router.Use(tc.Handler())
+		router.Handle(http.MethodGet, "/api/tags", tc.endpoint)
-			router.Handle(tc.Method, tc.Path, tc.Endpoint)
+		req, _ := http.NewRequest(http.MethodGet, "/api/tags", nil)
-			req, _ := http.NewRequest(tc.Method, tc.TestPath, nil)
 
-			if tc.Setup != nil {
+		resp := httptest.NewRecorder()
-				tc.Setup(t, req)
+		router.ServeHTTP(resp, req)
-			}
 
-			resp := httptest.NewRecorder()
+		var expected, actual map[string]any
-			router.ServeHTTP(resp, req)
+		err := json.Unmarshal([]byte(tc.resp), &expected)
+		if err != nil {
+			t.Fatalf("failed to unmarshal expected response: %v", err)
+		}
 
-			assert.Equal(t, http.StatusOK, resp.Code)
+		err = json.Unmarshal(resp.Body.Bytes(), &actual)
+		if err != nil {
+			t.Fatalf("failed to unmarshal actual response: %v", err)
+		}
 
-			tc.Expected(t, resp)
+		if !reflect.DeepEqual(expected, actual) {
-		})
+			t.Errorf("responses did not match\nExpected: %+v\nActual: %+v", expected, actual)
+		}
+	}
+}
+
+func TestRetrieveMiddleware(t *testing.T) {
+	type testCase struct {
+		name     string
+		endpoint func(c *gin.Context)
+		resp     string
+	}
+
+	testCases := []testCase{
+		{
+			name: "retrieve handler",
+			endpoint: func(c *gin.Context) {
+				c.JSON(http.StatusOK, api.ShowResponse{
+					ModifiedAt: time.Unix(int64(1686935002), 0).UTC(),
+				})
+			},
+			resp: `{
+				"id":"test-model",
+				"object":"model",
+				"created":1686935002,
+				"owned_by":"library"}
+			`,
+		},
+		{
+			name: "retrieve handler error forwarding",
+			endpoint: func(c *gin.Context) {
+				c.JSON(http.StatusBadRequest, gin.H{"error": "model not found"})
+			},
+			resp: `{
+				"error": {
+				  "code": null,
+				  "message": "model not found",
+				  "param": null,
+				  "type": "api_error"
+				}
+			}`,
+		},
+	}
+
+	gin.SetMode(gin.TestMode)
+
+	for _, tc := range testCases {
+		router := gin.New()
+		router.Use(RetrieveMiddleware())
+		router.Handle(http.MethodGet, "/api/show/:model", tc.endpoint)
+		req, _ := http.NewRequest(http.MethodGet, "/api/show/test-model", nil)
+
+		resp := httptest.NewRecorder()
+		router.ServeHTTP(resp, req)
+
+		var expected, actual map[string]any
+		err := json.Unmarshal([]byte(tc.resp), &expected)
+		if err != nil {
+			t.Fatalf("failed to unmarshal expected response: %v", err)
+		}
+
+		err = json.Unmarshal(resp.Body.Bytes(), &actual)
+		if err != nil {
+			t.Fatalf("failed to unmarshal actual response: %v", err)
+		}
+
+		if !reflect.DeepEqual(expected, actual) {
+			t.Errorf("responses did not match\nExpected: %+v\nActual: %+v", expected, actual)
+		}
 	}
 }