You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: speech_test.go
    path of file: ./repos/go-openai
    
    the code of the file until where you have to start completion: package openai_test

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"mime"
	"net/http"
	"os"
	"path/filepath"
	"testing"

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

func TestSpeechIntegration(t *testing.T) {
	client, server, teardown := setupOpenAITestServer()
	defer teardown()

	server.RegisterHandler("/v1/audio/speech", func(w http.ResponseWriter, r *http.Request) {
		dir, cleanup := test.CreateTestDirectory(t)
		path := filepath.Join(dir, "fake.mp3")
		test.CreateTestFile(t, path)
		defer cleanup()

		// audio endpoints only accept POST requests
		if r.Method != "POST" {
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}

		mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
		if err != nil {
			http.Error(w, "failed to parse media type", http.StatusBadRequest)
			return
		}

		if mediaType != "application/json" {
			http.Error(w, "request is not json", http.StatusBadRequest)
			return
		}

		// Parse the JSON body of the request
		var params map[string]interface{}
		err = json.NewDecoder(r.Body).Decode(&params)
		if err != nil {
			http.Error(w, "failed to parse request body", http.StatusBadRequest)
			return
		}

		// Check if each required field is present in the parsed JSON object
		reqParams := []string{"model", "input", "voice"}
		for _, param := range reqParams {
			_, ok := params[param]
			if !ok {
				http.Error(w, fmt.Sprintf("no %s in params", param), http.StatusBadRequest)
				return
			}
		}

		// read audio file content
		audioFile, err := os.ReadFile(path)
		if err != nil {
			http.Error(w, "failed to read audio file", http.StatusInternalServerError)
			return
		}

		// write audio file content to response
		w.Header().Set("Content-Type", "audio/mpeg")
		w.Header().Set("Transfer-Encoding", "chunked")
		w.Header().Set("Connection", "keep-alive")
		_, err = w.Write(audioFile)
		if err != nil {
			http.Error(w, "failed to write body", http.StatusInternalServerError)
			return
		}
	})

	t.Run("happy path", func(t *testing.T) {
		res, err := client.CreateSpeech(context.Background(), openai.CreateSpeechRequest{
			Model: openai.TTSModel1,
			Input: "Hello!",
			Voice: openai.VoiceAlloy,
		})
		checks.NoError(t, err, "CreateSpeech error")
		defer res.Close()

		buf, err := io.ReadAll(res)
		checks.NoError(t, err, "ReadAll error"
    
func TestSpeechIntegration(t *testing.T) {
	client, server, teardown := setupOpenAITestServer()
	defer teardown()

	server.RegisterHandler("/v1/audio/speech", func(w http.ResponseWriter, r *http.Request) {
		dir, cleanup := test.CreateTestDirectory(t)
		path := filepath.Join(dir, "fake.mp3")
		test.CreateTestFile(t, path)
		defer cleanup()

		// audio endpoints only accept POST requests
		if r.Method != "POST" {
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}

		mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
		if err != nil {
			http.Error(w, "failed to parse media type", http.StatusBadRequest)
			return
		}

		if mediaType != "application/json" {
			http.Error(w, "request is not json", http.StatusBadRequest)
			return
		}

		// Parse the JSON body of the request
		var params map[string]interface{}
		err = json.NewDecoder(r.Body).Decode(&params)
		if err != nil {
			http.Error(w, "failed to parse request body", http.StatusBadRequest)
			return
		}

		// Check if each required field is present in the parsed JSON object
		reqParams := []string{"model", "input", "voice"}
		for _, param := range reqParams {
			_, ok := params[param]
			if !ok {
				http.Error(w, fmt.Sprintf("no %s in params", param), http.StatusBadRequest)
				return
			}
		}

		// read audio file content
		audioFile, err := os.ReadFile(path)
		if err != nil {
			http.Error(w, "failed to read audio file", http.StatusInternalServerError)
			return
		}

		// write audio file content to response
		w.Header().Set("Content-Type", "audio/mpeg")
		w.Header().Set("Transfer-Encoding", "chunked")
		w.Header().Set("Connection", "keep-alive")
		_, err = w.Write(audioFile)
		if err != nil {
			http.Error(w, "failed to write body", http.StatusInternalServerError)
			return
		}
	})

	t.Run("happy path", func(t *testing.T) {
		res, err := client.CreateSpeech(context.Background(), openai.CreateSpeechRequest{
			Model: openai.TTSModel1,
			Input: "Hello!",
			Voice: openai.VoiceAlloy,
		})
		checks.NoError(t, err, "CreateSpeech error")
		defer res.Close()

		buf, err := io.ReadAll(res)
		checks.NoError(t, err, "ReadAll error")

		// save buf to file as mp3
		err = os.WriteFile("test.mp3", buf, 0644)
		checks.NoError(t, err, "Create error")
	})
	t.Run("invalid model", func(t *testing.T) {
		_, err := client.CreateSpeech(context.Background(), openai.CreateSpeechRequest{
			Model: "invalid_model",
			Input: "Hello!",
			Voice: openai.VoiceAlloy,
		})
		checks.ErrorIs(t, err, openai.ErrInvalidSpeechModel, "CreateSpeech error")
	})

	t.Run("invalid voice", func(t *testing.T) {
		_, err := client.CreateSpeech(context.Background(), openai.CreateSpeechRequest{
			Model: openai.TTSModel1,
			Input: "Hello!",
			Voice: "invalid_voice",
		})
		checks.ErrorIs(t, err, openai.ErrInvalidVoice, "CreateSpeech error")
	})
}