144 lines
3.4 KiB
Go
144 lines
3.4 KiB
Go
package gogpt_test
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"io"
|
|
"mime"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
. "github.com/sashabaranov/go-gpt3"
|
|
"github.com/sashabaranov/go-gpt3/internal/test"
|
|
|
|
"context"
|
|
"testing"
|
|
)
|
|
|
|
// TestAudio Tests the transcription and translation endpoints of the API using the mocked server.
|
|
func TestAudio(t *testing.T) {
|
|
server := test.NewTestServer()
|
|
server.RegisterHandler("/v1/audio/transcriptions", handleAudioEndpoint)
|
|
server.RegisterHandler("/v1/audio/translations", handleAudioEndpoint)
|
|
// create the test server
|
|
var err error
|
|
ts := server.OpenAITestServer()
|
|
ts.Start()
|
|
defer ts.Close()
|
|
|
|
config := DefaultConfig(test.GetTestToken())
|
|
config.BaseURL = ts.URL + "/v1"
|
|
client := NewClientWithConfig(config)
|
|
|
|
testcases := []struct {
|
|
name string
|
|
createFn func(context.Context, AudioRequest) (AudioResponse, error)
|
|
}{
|
|
{
|
|
"transcribe",
|
|
client.CreateTranscription,
|
|
},
|
|
{
|
|
"translate",
|
|
client.CreateTranslation,
|
|
},
|
|
}
|
|
|
|
ctx := context.Background()
|
|
|
|
dir, cleanup := createTestDirectory(t)
|
|
defer cleanup()
|
|
|
|
for _, tc := range testcases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
path := filepath.Join(dir, "fake.mp3")
|
|
createTestFile(t, path)
|
|
|
|
req := AudioRequest{
|
|
FilePath: path,
|
|
Model: "whisper-3",
|
|
}
|
|
_, err = tc.createFn(ctx, req)
|
|
if err != nil {
|
|
t.Fatalf("audio API error: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// createTestFile creates a fake file with "hello" as the content.
|
|
func createTestFile(t *testing.T, path string) {
|
|
file, err := os.Create(path)
|
|
if err != nil {
|
|
t.Fatalf("failed to create file %v", err)
|
|
}
|
|
if _, err = file.WriteString("hello"); err != nil {
|
|
t.Fatalf("failed to write to file %v", err)
|
|
}
|
|
file.Close()
|
|
}
|
|
|
|
// createTestDirectory creates a temporary folder which will be deleted when cleanup is called.
|
|
func createTestDirectory(t *testing.T) (path string, cleanup func()) {
|
|
t.Helper()
|
|
|
|
path, err := os.MkdirTemp(os.TempDir(), "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return path, func() { os.RemoveAll(path) }
|
|
}
|
|
|
|
// handleAudioEndpoint Handles the completion endpoint by the test server.
|
|
func handleAudioEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
|
|
// audio endpoints only accept POST requests
|
|
if r.Method != "POST" {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
}
|
|
|
|
mediaType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
http.Error(w, "failed to parse media type", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(mediaType, "multipart") {
|
|
http.Error(w, "request is not multipart", http.StatusBadRequest)
|
|
}
|
|
|
|
boundary, ok := params["boundary"]
|
|
if !ok {
|
|
http.Error(w, "no boundary in params", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
fileData := &bytes.Buffer{}
|
|
mr := multipart.NewReader(r.Body, boundary)
|
|
part, err := mr.NextPart()
|
|
if err != nil && errors.Is(err, io.EOF) {
|
|
http.Error(w, "error accessing file", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if _, err = io.Copy(fileData, part); err != nil {
|
|
http.Error(w, "failed to copy file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if len(fileData.Bytes()) == 0 {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
http.Error(w, "received empty file data", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if _, err = w.Write([]byte(`{"body": "hello"}`)); err != nil {
|
|
http.Error(w, "failed to write body", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|