files_api_test.go

package openai_test

import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"strconv"
"testing"
"time"

"github.com/sashabaranov/go-openai"
"github.com/sashabaranov/go-openai/internal/test/checks"
)

funcTestFileBytesUpload(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files", handleCreateFile)
req:= openai.FileBytesRequest{
Name: "foo",
Bytes: []byte("foo"),
Purpose: openai.PurposeFineTune,
 }
_, err:=client.CreateFileBytes(context.Background(), req)
checks.NoError(t, err, "CreateFile error")
}

funcTestFileUpload(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files", handleCreateFile)
req:= openai.FileRequest{
FileName: "test.go",
FilePath: "client.go",
Purpose: "fine-tune",
 }
_, err:=client.CreateFile(context.Background(), req)
checks.NoError(t, err, "CreateFile error")
}

// handleCreateFile Handles the images endpoint by the test server.
funchandleCreateFile(w http.ResponseWriter, r*http.Request) {
varerrerror
varresBytes []byte

// edits only accepts POST requests
ifr.Method!="POST" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 }
err=r.ParseMultipartForm(1024*1024*1024)
iferr!=nil {
http.Error(w, "file is more than 1GB", http.StatusInternalServerError)
return
 }

values:=r.Form
varpurposestring
forkey, value:=rangevalues {
ifkey=="purpose" {
purpose=value[0]
 }
 }
file, header, err:=r.FormFile("file")
iferr!=nil {
return
 }
deferfile.Close()

fileReq:= openai.File{
Bytes: int(header.Size),
ID: strconv.Itoa(int(time.Now().Unix())),
FileName: header.Filename,
Purpose: purpose,
CreatedAt: time.Now().Unix(),
Object: "test-objecct",
 }

resBytes, _=json.Marshal(fileReq)
fmt.Fprint(w, string(resBytes))
}

funcTestDeleteFile(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files/deadbeef", func(http.ResponseWriter, *http.Request) {})
err:=client.DeleteFile(context.Background(), "deadbeef")
checks.NoError(t, err, "DeleteFile error")
}

funcTestListFile(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files", func(w http.ResponseWriter, _*http.Request) {
resBytes, _:=json.Marshal(openai.FilesList{})
fmt.Fprintln(w, string(resBytes))
 })
_, err:=client.ListFiles(context.Background())
checks.NoError(t, err, "ListFiles error")
}

funcTestGetFile(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files/deadbeef", func(w http.ResponseWriter, _*http.Request) {
resBytes, _:=json.Marshal(openai.File{})
fmt.Fprintln(w, string(resBytes))
 })
_, err:=client.GetFile(context.Background(), "deadbeef")
checks.NoError(t, err, "GetFile error")
}

funcTestGetFileContent(t*testing.T) {
wantRespJsonl:=`{"prompt": "foo", "completion": "foo"}
{"prompt": "bar", "completion": "bar"}
{"prompt": "baz", "completion": "baz"}
`
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files/deadbeef/content", func(w http.ResponseWriter, r*http.Request) {
// edits only accepts GET requests
ifr.Method!=http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 }
fmt.Fprint(w, wantRespJsonl)
 })

content, err:=client.GetFileContent(context.Background(), "deadbeef")
checks.NoError(t, err, "GetFileContent error")
defercontent.Close()

actual, _:=io.ReadAll(content)
ifstring(actual) !=wantRespJsonl {
t.Errorf("Expected %s, got %s", wantRespJsonl, string(actual))
 }
}

funcTestGetFileContentReturnError(t*testing.T) {
wantMessage:="To help mitigate abuse, downloading of fine-tune training files is disabled for free accounts."
wantType:="invalid_request_error"
wantErrorResp:=`{
 "error": {
 "message": "`+wantMessage+`",
 "type": "`+wantType+`",
 "param": null,
 "code": null
 }
}`
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files/deadbeef/content", func(w http.ResponseWriter, _*http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusBadRequest)
fmt.Fprint(w, wantErrorResp)
 })

_, err:=client.GetFileContent(context.Background(), "deadbeef")
iferr==nil {
t.Fatal("Did not return error")
 }

apiErr:=&openai.APIError{}
if!errors.As(err, &apiErr) {
t.Fatalf("Did not return APIError: %+v\n", apiErr)
 }
ifapiErr.Message!=wantMessage {
t.Fatalf("Expected %s Message, got = %s\n", wantMessage, apiErr.Message)
return
 }
ifapiErr.Type!=wantType {
t.Fatalf("Expected %s Type, got = %s\n", wantType, apiErr.Type)
return
 }
}

funcTestGetFileContentReturnTimeoutError(t*testing.T) {
client, server, teardown:=setupOpenAITestServer()
deferteardown()
server.RegisterHandler("/v1/files/deadbeef/content", func(http.ResponseWriter, *http.Request) {
time.Sleep(10*time.Nanosecond)
 })
ctx:=context.Background()
ctx, cancel:=context.WithTimeout(ctx, time.Nanosecond)
defercancel()

_, err:=client.GetFileContent(ctx, "deadbeef")
iferr==nil {
t.Fatal("Did not return error")
 }
if!os.IsTimeout(err) {
t.Fatal("Did not return timeout error")
 }
}