Xurl

name: Go

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:

  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4

    - name: Set up Go
      uses: actions/setup-go@v4
      with:
        go-version: '1.24'

    - name: Build
      run: go build -v ./...

    - name: Run tests
      run: go test -v ./...

    - name: Run lint
      run: gofmt -l .

name: Release

on:
  push:
    tags:
      - "v*"

permissions:
  contents: write

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: "1.24"

      - name: Run tests
        run: go test ./...

      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@v6
        with:
          version: "~> v2"
          args: release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          HOMEBREW_TAP_GITHUB_TOKEN: ${{ secrets.HOMEBREW_TAP_GITHUB_TOKEN }}

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
          registry-url: "https://registry.npmjs.org"

      - name: Update npm package version
        run: |
          VERSION=${GITHUB_REF_NAME#v}
          cd npm
          npm version "$VERSION" --no-git-tag-version

      - name: Unpublish npm version if it exists
        continue-on-error: true
        run: |
          VERSION=${GITHUB_REF_NAME#v}
          npm unpublish "@xdevplatform/xurl@${VERSION}" --registry=https://registry.npmjs.org
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

      - name: Publish to npm
        run: |
          cd npm
          npm publish --access public
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

xurl
.xurl_test
.DS_Store# Added by goreleaser init:
dist/

# This is an example .goreleaser.yml file with some sensible defaults.
# Make sure to check the documentation at https://goreleaser.com

# The lines below are called `modelines`. See `:help modeline`
# Feel free to remove those if you don't want/need to use them.
# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
# vim: set ts=2 sw=2 tw=0 fo=cnqoj

version: 2

before:
  hooks:
    # You may remove this if you don't use go modules.
    - go mod tidy
    # you may remove this if you don't need go generate
    - go generate ./...

builds:
  - env:
      - CGO_ENABLED=0
    goos:
      - linux
      - windows
      - darwin
    ldflags:
      - -s -w
      - -X github.com/xdevplatform/xurl/version.Version={{.Version}}
      - -X github.com/xdevplatform/xurl/version.Commit={{.Commit}}
      - -X github.com/xdevplatform/xurl/version.BuildDate={{.Date}}

archives:
  - formats: [tar.gz]
    # this name template makes the OS and Arch compatible with the results of `uname`.
    name_template: >-
      {{ .ProjectName }}_
      {{- title .Os }}_
      {{- if eq .Arch "amd64" }}x86_64
      {{- else if eq .Arch "386" }}i386
      {{- else }}{{ .Arch }}{{ end }}
      {{- if .Arm }}v{{ .Arm }}{{ end }}
    # use zip for windows archives
    format_overrides:
      - goos: windows
        formats: [zip]

changelog:
  sort: asc
  filters:
    exclude:
      - "^docs:"
      - "^test:"

homebrew_casks:
  - name: xurl
    repository:
      owner: xdevplatform
      name: homebrew-tap
      token: "{{ .Env.HOMEBREW_TAP_GITHUB_TOKEN }}"
    homepage: "https://github.com/xdevplatform/xurl"
    description: "Auth-enabled curl-like CLI for the X API"
    hooks:
      post:
        install: |
          if OS.mac?
            system_command "/usr/bin/xattr", args: ["-dr", "com.apple.quarantine", "#{staged_path}/xurl"]
          end

release:
  footer: >-

    ---

    Released by [GoReleaser](https://github.com/goreleaser/goreleaser).

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${workspaceFolder}",
            "args": ["auth", "oauth2"],
            "cwd": "${workspaceFolder}"
        }
    ]
}

{
  "files.watcherExclude": {
    "**/target": true
  }
}

package api

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/xdevplatform/xurl/auth"
	"github.com/xdevplatform/xurl/config"
	xurlErrors "github.com/xdevplatform/xurl/errors"
	"github.com/xdevplatform/xurl/store"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Helper function to create a temporary token store for testing
func createTempTokenStore(t *testing.T) (*store.TokenStore, string) {
	tempDir, err := os.MkdirTemp("", "xurl_test")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}

	tempFile := filepath.Join(tempDir, ".xurl")
	tokenStore := &store.TokenStore{
		Apps:       make(map[string]*store.App),
		DefaultApp: "default",
		FilePath:   tempFile,
	}
	tokenStore.Apps["default"] = &store.App{
		OAuth2Tokens: make(map[string]store.Token),
	}

	return tokenStore, tempDir
}

// Create a mock Auth for testing
func createMockAuth(t *testing.T) (*auth.Auth, string) {
	cfg := &config.Config{
		ClientID:     "test-client-id",
		ClientSecret: "test-client-secret",
		RedirectURI:  "http://localhost:8080/callback",
		AuthURL:      "https://x.com/i/oauth2/authorize",
		TokenURL:     "https://api.x.com/2/oauth2/token",
		APIBaseURL:   "https://api.x.com",
		InfoURL:      "https://api.x.com/2/users/me",
	}

	mockAuth := auth.NewAuth(cfg)
	tokenStore, tempDir := createTempTokenStore(t)

	err := tokenStore.SaveBearerToken("test-bearer-token")
	if err != nil {
		t.Fatalf("Failed to save bearer token: %v", err)
	}

	mockAuth.WithTokenStore(tokenStore)
	return mockAuth, tempDir
}

func TestNewApiClient(t *testing.T) {
	cfg := &config.Config{
		APIBaseURL: "https://api.x.com",
	}
	auth, tempDir := createMockAuth(t)
	defer os.RemoveAll(tempDir)

	client := NewApiClient(cfg, auth)

	assert.Equal(t, cfg.APIBaseURL, client.url, "URL should match config")
	assert.Equal(t, auth, client.auth, "Auth should be set correctly")
	assert.NotNil(t, client.client, "HTTP client should not be nil")
}

func TestBuildRequest(t *testing.T) {
	// Setup
	cfg := &config.Config{
		APIBaseURL: "https://api.x.com",
	}
	authMock, tempDir := createMockAuth(t)
	defer os.RemoveAll(tempDir)

	client := NewApiClient(cfg, authMock)

	tests := []struct {
		name       string
		method     string
		endpoint   string
		headers    []string
		data       string
		authType   string
		username   string
		wantMethod string
		wantURL    string
		wantErr    bool
	}{
		{
			name:       "GET user profile",
			method:     "GET",
			endpoint:   "/2/users/me",
			headers:    []string{"Accept: application/json"},
			data:       "",
			authType:   "",
			username:   "",
			wantMethod: "GET",
			wantURL:    "https://api.x.com/2/users/me",
			wantErr:    false,
		},
		{
			name:       "POST tweet",
			method:     "POST",
			endpoint:   "/2/tweets",
			headers:    []string{"Accept: application/json", "Authorization: Bearer test-token"},
			data:       `{"text":"Hello world!"}`,
			authType:   "oauth1",
			username:   "",
			wantMethod: "POST",
			wantURL:    "https://api.x.com/2/tweets",
			wantErr:    false,
		},
		{
			name:       "Absolute URL",
			method:     "GET",
			endpoint:   "https://api.x.com/2/tweets/search/stream",
			headers:    []string{"Authorization: Bearer test-token"},
			data:       "",
			authType:   "app",
			username:   "",
			wantMethod: "GET",
			wantURL:    "https://api.x.com/2/tweets/search/stream",
			wantErr:    false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			requestOptions := RequestOptions{
				Method:   tt.method,
				Endpoint: tt.endpoint,
				Headers:  tt.headers,
				AuthType: tt.authType,
				Username: tt.username,
				Data:     tt.data,
			}

			req, err := client.BuildRequest(requestOptions)

			if tt.wantErr {
				assert.Error(t, err)
				return
			}

			require.NoError(t, err)
			assert.Equal(t, tt.wantMethod, req.Method)
			assert.Equal(t, tt.wantURL, req.URL.String())

			for _, header := range tt.headers {
				parts := strings.Split(header, ": ")
				require.Len(t, parts, 2, "Invalid header format: %s", header)

				key := strings.TrimSpace(parts[0])
				value := strings.TrimSpace(parts[1])

				assert.Equal(t, value, req.Header.Get(key))
			}

			assert.Equal(t, "xurl/dev", req.Header.Get("User-Agent"))

			if tt.method == "POST" && tt.data != "" {
				assert.Equal(t, "application/json", req.Header.Get("Content-Type"))
			}
		})
	}
}

func TestSendRequest(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/2/users/me" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(`{"data":{"id":"12345","name":"Test User","username":"testuser"}}`))
			return
		}

		if r.URL.Path == "/2/tweets" && r.Method == "POST" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			w.Write([]byte(`{"data":{"id":"67890","text":"Hello world!"}}`))
			return
		}

		if r.URL.Path == "/2/tweets/search/recent" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusBadRequest)
			w.Write([]byte(`{"errors":[{"message":"Invalid query","code":400}]}`))
			return
		}

		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	cfg := &config.Config{
		APIBaseURL: server.URL,
	}
	authMock, tempDir := createMockAuth(t)
	defer os.RemoveAll(tempDir)
	client := NewApiClient(cfg, authMock)

	// Test successful GET request
	t.Run("Get user profile", func(t *testing.T) {
		options := RequestOptions{
			Method:   "GET",
			Endpoint: "/2/users/me",
			Headers:  []string{"Authorization: Bearer test-token"},
			Data:     "",
			AuthType: "",
			Username: "",
			Verbose:  false,
		}

		resp, err := client.SendRequest(options)

		require.NoError(t, err)

		var result map[string]any
		err = json.Unmarshal(resp, &result)
		require.NoError(t, err, "Failed to parse response")

		data, ok := result["data"].(map[string]any)
		require.True(t, ok, "Expected data object in response")

		assert.Equal(t, "testuser", data["username"], "Username should match")
	})

	// Test successful POST request
	t.Run("Post tweet", func(t *testing.T) {
		options := RequestOptions{
			Method:   "POST",
			Endpoint: "/2/tweets",
			Headers:  []string{"Authorization: Bearer test-token"},
			Data:     `{"text":"Hello world!"}`,
			AuthType: "",
			Username: "",
			Verbose:  false,
		}

		resp, err := client.SendRequest(options)

		require.NoError(t, err)

		var result map[string]any
		err = json.Unmarshal(resp, &result)
		require.NoError(t, err, "Failed to parse response")

		data, ok := result["data"].(map[string]any)
		require.True(t, ok, "Expected data object in response")

		assert.Equal(t, "Hello world!", data["text"], "Tweet text should match")
	})

	t.Run("Error response", func(t *testing.T) {
		options := RequestOptions{
			Method:   "GET",
			Endpoint: "/2/tweets/search/recent",
			Headers:  []string{"Authorization: Bearer test-token"},
			Data:     "",
			AuthType: "",
			Username: "",
			Verbose:  false,
		}

		resp, err := client.SendRequest(options)

		assert.Error(t, err, "Expected an error")
		assert.Nil(t, resp, "Response should be nil")
		assert.True(t, xurlErrors.IsAPIError(err), "Expected API error")
	})
}

func TestGetAuthHeader(t *testing.T) {
	cfg := &config.Config{
		APIBaseURL: "https://api.x.com",
	}

	t.Run("No auth set", func(t *testing.T) {
		client := NewApiClient(cfg, nil)

		_, err := client.getAuthHeader("GET", "https://api.x.com/2/users/me", "", "")

		assert.Error(t, err, "Expected an error")
		assert.True(t, xurlErrors.IsAuthError(err), "Expected auth error")
	})

	t.Run("Invalid auth type", func(t *testing.T) {
		authMock, tempDir := createMockAuth(t)
		defer os.RemoveAll(tempDir)
		client := NewApiClient(cfg, authMock)

		_, err := client.getAuthHeader("GET", "https://api.x.com/2/users/me", "invalid", "")

		assert.Error(t, err, "Expected an error")
		assert.True(t, xurlErrors.IsAuthError(err), "Expected auth error")
	})

	t.Run("Auto-detect uses named app bearer token when --app is set", func(t *testing.T) {
		tokenStore, tempDir := createTempTokenStore(t)
		defer os.RemoveAll(tempDir)

		tokenStore.AddApp("my-app", "id", "secret")
		// Bearer token only in my-app, not in default
		tokenStore.SaveBearerTokenForApp("my-app", "bearer-my-app")

		a := auth.NewAuth(&config.Config{}).WithTokenStore(tokenStore).WithAppName("my-app")
		client := NewApiClient(cfg, a)

		header, err := client.getAuthHeader("GET", "https://api.x.com/2/users/me", "", "")
		require.NoError(t, err)
		assert.Equal(t, "Bearer bearer-my-app", header)
	})

	t.Run("Auto-detect falls back to default app when no --app flag", func(t *testing.T) {
		tokenStore, tempDir := createTempTokenStore(t)
		defer os.RemoveAll(tempDir)

		tokenStore.AddApp("other-app", "id", "secret")
		// Bearer token only in default app
		tokenStore.SaveBearerTokenForApp("default", "bearer-default")
		tokenStore.SaveBearerTokenForApp("other-app", "bearer-other")

		// No WithAppName — should use default
		a := auth.NewAuth(&config.Config{}).WithTokenStore(tokenStore)
		client := NewApiClient(cfg, a)

		header, err := client.getAuthHeader("GET", "https://api.x.com/2/users/me", "", "")
		require.NoError(t, err)
		assert.Equal(t, "Bearer bearer-default", header)
	})
}

func TestStreamRequest(t *testing.T) {
	// This is a basic test for the StreamRequest method
	// A more comprehensive test would require mocking the streaming response

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/2/tweets/search/stream" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			// In a real test, we would write multiple JSON objects with flushing
			// but for this simple test, we'll just close the connection
			return
		}

		if r.URL.Path == "/2/tweets/search/stream/error" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusBadRequest)
			w.Write([]byte(`{"errors":[{"message":"Invalid rule","code":400}]}`))
			return
		}

		w.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()

	cfg := &config.Config{
		APIBaseURL: server.URL,
	}
	authMock, tempDir := createMockAuth(t)
	defer os.RemoveAll(tempDir)
	client := NewApiClient(cfg, authMock)

	t.Run("Stream error response", func(t *testing.T) {
		options := RequestOptions{
			Method:   "GET",
			Endpoint: "/2/tweets/search/stream/error",
			Headers:  []string{"Authorization: Bearer test-token"},
			Data:     "",
			AuthType: "",
			Username: "",
			Verbose:  false,
		}

		err := client.StreamRequest(options)

		assert.Error(t, err, "Expected an error")
		assert.True(t, xurlErrors.IsAPIError(err), "Expected API error")
	})
}

package api

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"

	"bufio"
	"mime/multipart"
	"os"
	"path/filepath"
	"github.com/xdevplatform/xurl/auth"
	"github.com/xdevplatform/xurl/config"
	xurlErrors "github.com/xdevplatform/xurl/errors"
	"github.com/xdevplatform/xurl/version"
)

// RequestOptions contains common options for API requests
type RequestOptions struct {
	Method   string
	Endpoint string
	Headers  []string
	Data     string
	AuthType string
	Username string
	Verbose  bool
	Trace    bool
}

// MultipartOptions contains options specific to multipart requests
type MultipartOptions struct {
	RequestOptions
	FormFields map[string]string
	FileField  string
	FilePath   string
	FileName   string
	FileData   []byte
}

// Client is an interface for API clients
type Client interface {
	BuildRequest(requestOptions RequestOptions) (*http.Request, error)
	BuildMultipartRequest(options MultipartOptions) (*http.Request, error)
	SendRequest(options RequestOptions) (json.RawMessage, error)
	StreamRequest(options RequestOptions) error
	SendMultipartRequest(options MultipartOptions) (json.RawMessage, error)
}

// ApiClient handles API requests
type ApiClient struct {
	url    string
	client *http.Client
	auth   *auth.Auth
}

// NewApiClient creates a new ApiClient
func NewApiClient(config *config.Config, auth *auth.Auth) *ApiClient {
	return &ApiClient{
		url:    config.APIBaseURL,
		client: &http.Client{Timeout: 30 * time.Second},
		auth:   auth,
	}
}

// BuildRequest builds an HTTP request
func (c *ApiClient) BuildRequest(requestOptions RequestOptions) (*http.Request, error) {
	httpMethod := strings.ToUpper(requestOptions.Method)

	var body io.Reader
	contentType := ""

	if requestOptions.Data != "" && (httpMethod == "POST" || httpMethod == "PUT" || httpMethod == "PATCH") {
		body = bytes.NewBufferString(requestOptions.Data)

		var js json.RawMessage
		if json.Unmarshal([]byte(requestOptions.Data), &js) == nil {
			contentType = "application/json"
		} else {
			contentType = "application/x-www-form-urlencoded"
		}
	}

	return c.buildBaseRequest(
		requestOptions.Method,
		requestOptions.Endpoint,
		body,
		contentType,
		requestOptions.Headers,
		requestOptions.AuthType,
		requestOptions.Username,
		requestOptions.Trace,
	)
}

// BuildMultipartRequest builds an HTTP request with multipart form data
func (c *ApiClient) BuildMultipartRequest(options MultipartOptions) (*http.Request, error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	// Handle file from path
	if options.FileField != "" && options.FilePath != "" {
		file, err := os.Open(options.FilePath)
		if err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error opening file: %v", err))
		}
		defer file.Close()

		part, err := writer.CreateFormFile(options.FileField, filepath.Base(options.FilePath))
		if err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error creating form file: %v", err))
		}

		if _, err := io.Copy(part, file); err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error copying file content: %v", err))
		}
	} else if options.FileField != "" && len(options.FileData) > 0 { // Handle file from buffer
		part, err := writer.CreateFormFile(options.FileField, options.FileName)
		if err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error creating form file: %v", err))
		}

		if _, err := part.Write(options.FileData); err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error writing file data: %v", err))
		}
	}

	for key, value := range options.FormFields {
		if err := writer.WriteField(key, value); err != nil {
			return nil, xurlErrors.NewIOError(fmt.Errorf("error writing form field: %v", err))
		}
	}

	if err := writer.Close(); err != nil {
		return nil, xurlErrors.NewIOError(fmt.Errorf("error closing multipart writer: %v", err))
	}

	// Use the common base request builder with the multipart content type
	return c.buildBaseRequest(
		options.Method,
		options.Endpoint,
		body,
		writer.FormDataContentType(),
		options.Headers,
		options.AuthType,
		options.Username,
		options.Trace,
	)
}

// SendRequest sends an HTTP request
func (c *ApiClient) SendRequest(options RequestOptions) (json.RawMessage, error) {
	req, err := c.BuildRequest(options)
	if err != nil {
		return nil, xurlErrors.NewHTTPError(err)
	}

	c.logRequest(req, options.Verbose)

	resp, err := c.client.Do(req)
	if err != nil {
		return nil, xurlErrors.NewHTTPError(err)
	}
	defer resp.Body.Close()

	return c.processResponse(resp, options.Verbose)
}

// SendMultipartRequest sends an HTTP request with multipart form data
func (c *ApiClient) SendMultipartRequest(options MultipartOptions) (json.RawMessage, error) {
	req, err := c.BuildMultipartRequest(options)
	if err != nil {
		return nil, err
	}

	c.logRequest(req, options.Verbose)

	resp, err := c.client.Do(req)
	if err != nil {
		return nil, xurlErrors.NewHTTPError(err)
	}
	defer resp.Body.Close()

	return c.processResponse(resp, options.Verbose)
}

// StreamRequest sends an HTTP request and streams the response
func (c *ApiClient) StreamRequest(options RequestOptions) error {
	req, err := c.BuildRequest(options)
	if err != nil {
		return xurlErrors.NewHTTPError(err)
	}

	if options.Verbose {
		fmt.Printf("\033[1;34m> %s\033[0m %s\n", req.Method, req.URL)
		for key, values := range req.Header {
			for _, value := range values {
				fmt.Printf("\033[1;36m> %s\033[0m: %s\n", key, value)
			}
		}
		fmt.Println()
	}

	client := &http.Client{
		Timeout: 0,
	}

	fmt.Printf("\033[1;32mConnecting to streaming endpoint: %s\033[0m\n", options.Endpoint)

	resp, err := client.Do(req)
	if err != nil {
		return xurlErrors.NewHTTPError(err)
	}
	defer resp.Body.Close()

	if options.Verbose {
		fmt.Printf("\033[1;31m< %s\033[0m\n", resp.Status)
		for key, values := range resp.Header {
			for _, value := range values {
				fmt.Printf("\033[1;32m< %s\033[0m: %s\n", key, value)
			}
		}
		fmt.Println()
	}

	if resp.StatusCode >= 400 {
		body, err := io.ReadAll(resp.Body)
		if err != nil {
			return xurlErrors.NewIOError(err)
		}

		var js json.RawMessage
		if err := json.Unmarshal(body, &js); err != nil {
			return xurlErrors.NewJSONError(err)
		}

		return xurlErrors.NewAPIError(js)
	}

	scanner := bufio.NewScanner(resp.Body)

	const maxScanTokenSize = 1024 * 1024
	buf := make([]byte, maxScanTokenSize)
	scanner.Buffer(buf, maxScanTokenSize)

	fmt.Println("\033[1;32m--- Streaming response started ---\033[0m")
	fmt.Println("\033[1;32m--- Press Ctrl+C to stop ---\033[0m")

	for scanner.Scan() {
		line := scanner.Text()

		if line == "" {
			continue
		}
		// We can't pretty-print streaming responses
		fmt.Println(line)
	}

	if err := scanner.Err(); err != nil {
		if err == bufio.ErrTooLong {
			return xurlErrors.NewIOError(fmt.Errorf("line too long: increase buffer size"))
		}
		return xurlErrors.NewIOError(err)
	}

	fmt.Println("\033[1;32m--- End of stream ---\033[0m")
	return nil
}

// buildBaseRequest creates the base HTTP request with common headers and settings
func (c *ApiClient) buildBaseRequest(method, endpoint string, body io.Reader, contentType string, headers []string, authType, username string, trace bool) (*http.Request, error) {
	httpMethod := strings.ToUpper(method)

	// Build the full URL
	url := endpoint
	if !strings.HasPrefix(strings.ToLower(endpoint), "http") {
		url = c.url
		if !strings.HasSuffix(url, "/") {
			url += "/"
		}
		if strings.HasPrefix(endpoint, "/") {
			url += endpoint[1:]
		} else {
			url += endpoint
		}
	}

	// Create the request
	req, err := http.NewRequest(httpMethod, url, body)
	if err != nil {
		return nil, xurlErrors.NewHTTPError(err)
	}

	// Add headers
	for _, header := range headers {
		parts := strings.SplitN(header, ":", 2)
		if len(parts) == 2 {
			req.Header.Add(strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]))
		}
	}

	// Set content type if provided
	if contentType != "" {
		req.Header.Set("Content-Type", contentType)
	}

	// Add authorization header if not already set
	if req.Header.Get("Authorization") == "" {
		authHeader, err := c.getAuthHeader(httpMethod, url, authType, username)
		if err == nil {
			req.Header.Add("Authorization", authHeader)
		}
	}

	// Add common headers
	req.Header.Add("User-Agent", "xurl/"+version.Version)

	if trace {
		req.Header.Add("X-B3-Flags", "1")
	}

	return req, nil
}

// GetAuthHeader gets the authorization header for a request
func (c *ApiClient) getAuthHeader(method, url string, authType string, username string) (string, error) {
	if c.auth == nil {
		return "", xurlErrors.NewAuthError("AuthNotSet", errors.New("auth not set"))
	}

	if authType != "" {
		switch strings.ToLower(authType) {
		case "oauth1":
			return c.auth.GetOAuth1Header(method, url, nil)
		case "oauth2":
			return c.auth.GetOAuth2Header(username)
		case "app":
			return c.auth.GetBearerTokenHeader()
		default:
			return "", xurlErrors.NewAuthError("InvalidAuthType", fmt.Errorf("invalid auth type: %s", authType))
		}
	}

	// If no auth type is specified, try to use the first OAuth2 token
	appName := c.auth.AppName()
	token := c.auth.TokenStore.GetFirstOAuth2TokenForApp(appName)
	if token != nil {
		accessToken, err := c.auth.GetOAuth2Header(username)
		if err == nil {
			return accessToken, nil
		}
	}

	// If no OAuth2 token is available, try to use the first OAuth1 token
	token = c.auth.TokenStore.GetOAuth1TokensForApp(appName)
	if token != nil {
		authHeader, err := c.auth.GetOAuth1Header(method, url, nil)
		if err == nil {
			return authHeader, nil
		}
	}

	// If no OAuth1 token is available, try to use the bearer token
	bearerToken, err := c.auth.GetBearerTokenHeader()
	if err == nil {
		return bearerToken, nil
	}

	// If no authentication method is available, return an error
	return "", xurlErrors.NewAuthError("NoAuthMethod", errors.New("no authentication method available"))
}

// logRequest logs request details if verbose mode is enabled
func (c *ApiClient) logRequest(req *http.Request, verbose bool) {
	if verbose {
		fmt.Printf("\033[1;34m> %s\033[0m %s\n", req.Method, req.URL)
		for key, values := range req.Header {
			for _, value := range values {
				fmt.Printf("\033[1;36m> %s\033[0m: %s\n", key, value)
			}
		}
		fmt.Println()
	}
}

// processResponse handles common response processing logic
func (c *ApiClient) processResponse(resp *http.Response, verbose bool) (json.RawMessage, error) {
	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, xurlErrors.NewIOError(err)
	}

	if verbose {
		fmt.Printf("\033[1;31m< %s\033[0m\n", resp.Status)
		for key, values := range resp.Header {
			for _, value := range values {
				fmt.Printf("\033[1;32m< %s\033[0m: %s\n", key, value)
			}
		}
		fmt.Println()
	}

	var js json.RawMessage
	if len(responseBody) > 0 {
		if err := json.Unmarshal(responseBody, &js); err != nil {
			if resp.StatusCode >= 400 {
				return nil, xurlErrors.NewHTTPError(fmt.Errorf("HTTP error: %s", resp.Status))
			}
			js = json.RawMessage("{}")
		}
	} else {
		js = json.RawMessage("{}")
	}

	if resp.StatusCode >= 400 {
		return nil, xurlErrors.NewAPIError(js)
	}

	return js, nil
}

package api

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestIsStreamingEndpoint(t *testing.T) {
	testCases := []struct {
		endpoint string
		expected bool
	}{
		// Test exact matches
		{"/2/tweets/search/stream", true},
		{"/2/tweets/sample/stream", true},
		{"/2/tweets/sample10/stream", true},
		{"/2/tweets/firehose/stream", true},
		{"/2/tweets/firehose/stream/lang/en", true},
		{"/2/tweets/firehose/stream/lang/ja", true},
		{"/2/tweets/firehose/stream/lang/ko", true},
		{"/2/tweets/firehose/stream/lang/pt", true},

		// Test with trailing slash
		{"/2/tweets/search/stream/", true},

		// Test with query parameters
		{"/2/tweets/search/stream?query=test", true},

		// Test with full URL
		{"https://api.x.com/2/tweets/search/stream", true},
		{"http://api.x.com/2/tweets/search/stream", true},
		{"https://api.x.com/2/tweets/search/stream?query=test", true},

		// Test non-streaming endpoints
		{"/2/tweets/search/recent", false},
		{"/2/users/me", false},
		{"https://api.x.com/2/users/me", false},
		{"/not/a/streaming/endpoint", false},
		{"", false},
	}

	for _, tc := range testCases {
		t.Run(tc.endpoint, func(t *testing.T) {
			result := IsStreamingEndpoint(tc.endpoint)
			assert.Equal(t, tc.expected, result, "IsStreamingEndpoint(%q) should return %v", tc.endpoint, tc.expected)
		})
	}
}

package api

import (
	"strings"
)

// StreamingEndpoints is a map of endpoint prefixes that should be streamed
var StreamingEndpoints = map[string]bool{
	"/2/tweets/search/stream":           true,
	"/2/tweets/sample/stream":           true,
	"/2/tweets/sample10/stream":         true,
	"/2/tweets/firehose/stream":         true,
	"/2/tweets/firehose/stream/lang/en": true,
	"/2/tweets/firehose/stream/lang/ja": true,
	"/2/tweets/firehose/stream/lang/ko": true,
	"/2/tweets/firehose/stream/lang/pt": true,
}

// IsStreamingEndpoint checks if an endpoint should be streamed
func IsStreamingEndpoint(endpoint string) bool {
	path := endpoint
	if strings.HasPrefix(strings.ToLower(endpoint), "http") {
		parsedURL := strings.SplitN(endpoint, "/", 4)
		if len(parsedURL) >= 4 {
			path = "/" + parsedURL[3]
		}
	}

	// Remove query parameters if present
	if queryIndex := strings.Index(path, "?"); queryIndex != -1 {
		path = path[:queryIndex]
	}

	normalizedEndpoint := strings.TrimSuffix(path, "/")

	return StreamingEndpoints[normalizedEndpoint]
}

package api

import (
	"encoding/json"
	"fmt"
	"github.com/xdevplatform/xurl/utils"
)

// ExecuteRequest handles the execution of a regular API request
func ExecuteRequest(options RequestOptions, client Client) error {

	response, clientErr := client.SendRequest(options)
	if clientErr != nil {
		return handleRequestError(clientErr)
	}

	return utils.FormatAndPrintResponse(response)
}

// ExecuteStreamRequest handles the execution of a streaming API request
func ExecuteStreamRequest(options RequestOptions, client Client) error {

	clientErr := client.StreamRequest(options)
	if clientErr != nil {
		return handleRequestError(clientErr)
	}

	return nil
}

// handleRequestError processes API client errors in a consistent way
func handleRequestError(clientErr error) error {
	var rawJSON json.RawMessage
	json.Unmarshal([]byte(clientErr.Error()), &rawJSON)
	utils.FormatAndPrintResponse(rawJSON)
	return fmt.Errorf("request failed")
}

// formatAndPrintResponse formats and prints API responses

// HandleRequest determines the type of request and executes it accordingly
func HandleRequest(options RequestOptions, forceStream bool, mediaFile string, client Client) error {
	if IsMediaAppendRequest(options.Endpoint, mediaFile) {
		response, err := HandleMediaAppendRequest(options, mediaFile, client)
		if err != nil {
			return err
		}

		return utils.FormatAndPrintResponse(response)
	}

	shouldStream := forceStream || IsStreamingEndpoint(options.Endpoint)

	if shouldStream {
		return ExecuteStreamRequest(options, client)
	} else {
		return ExecuteRequest(options, client)
	}
}

package api

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

// MockApiClient is a mock implementation of the ApiClient for testing
type MockApiClient struct {
	mock.Mock
}

func (m *MockApiClient) SendRequest(options RequestOptions) (json.RawMessage, error) {
	args := m.Called(options)
	return args.Get(0).(json.RawMessage), args.Error(1)
}

func (m *MockApiClient) SendMultipartRequest(options MultipartOptions) (json.RawMessage, error) {
	args := m.Called(options)
	return args.Get(0).(json.RawMessage), args.Error(1)
}

func (m *MockApiClient) BuildRequest(requestOptions RequestOptions) (*http.Request, error) {
	args := m.Called(requestOptions)
	return args.Get(0).(*http.Request), args.Error(1)
}

func (m *MockApiClient) BuildMultipartRequest(options MultipartOptions) (*http.Request, error) {
	args := m.Called(options)
	return args.Get(0).(*http.Request), args.Error(1)
}

func (m *MockApiClient) StreamRequest(options RequestOptions) error {
	args := m.Called(options.Method, options.Endpoint, options.Headers, options.Data, options.AuthType, options.Username, options.Verbose)
	return args.Error(0)
}

// Helper function to create a temporary test file
func createTempTestFile(t *testing.T, size int) (string, []byte) {
	tempFile, err := os.CreateTemp("", "media_test_*.txt")
	if err != nil {
		t.Fatalf("Failed to create temp file: %v", err)
	}

	data := make([]byte, size)
	for i := range data {
		data[i] = byte(i % 256)
	}

	if _, err := tempFile.Write(data); err != nil {
		t.Fatalf("Failed to write to temp file: %v", err)
	}

	if err := tempFile.Close(); err != nil {
		t.Fatalf("Failed to close temp file: %v", err)
	}

	return tempFile.Name(), data
}

func TestNewMediaUploader(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, true, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)
	assert.NotNil(t, uploader)
	assert.Equal(t, tempFile, uploader.filePath)
	assert.Equal(t, int64(1024), uploader.fileSize)
	assert.Equal(t, true, uploader.verbose)
	assert.Equal(t, "oauth2", uploader.authType)
	assert.Equal(t, "testuser", uploader.username)

	uploader, err = NewMediaUploader(mockClient, "nonexistent.txt", false, false, "oauth2", "testuser", []string{})
	assert.Error(t, err)
	assert.Nil(t, uploader)

	tempDir, err := os.MkdirTemp("", "media_test_dir")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	defer os.RemoveAll(tempDir)

	uploader, err = NewMediaUploader(mockClient, tempDir, false, false, "oauth2", "testuser", []string{})
	assert.Error(t, err)
	assert.Nil(t, uploader)
}

func TestMediaUploader_Init(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	initResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"expires_after_secs": 3600,
			"media_key": "test_media_key"
		}
	}`)

	expectedUrl := MediaEndpoint + "/initialize"
	data := InitRequest{
		TotalBytes:    1024,
		MediaType:     "image/jpeg",
		MediaCategory: "tweet_image",
	}
	jsonData, err := json.Marshal(data)
	if err != nil {
		t.Fatalf("Failed to marshal jsonData: %v", err)
	}
	requestOptions := RequestOptions{
		Method:   "POST",
		Endpoint: expectedUrl,
		Headers:  []string{},
		Data:     string(jsonData),
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	mockClient.On("SendRequest", requestOptions).Return(initResponse, nil)

	err = uploader.Init("image/jpeg", "tweet_image")
	assert.NoError(t, err)
	assert.Equal(t, "test_media_id", uploader.GetMediaID())

	mockClient.AssertExpectations(t)

	mockClient = new(MockApiClient)
	uploader, err = NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	mockClient.On("SendRequest", requestOptions).Return(json.RawMessage("{}"), assert.AnError)

	err = uploader.Init("image/jpeg", "tweet_image")
	assert.Error(t, err)

	mockClient.AssertExpectations(t)
}

func TestMediaUploader_Append(t *testing.T) {
	mockClient := new(MockApiClient)

	fileSize := 8 * 1024 * 1024
	tempFile, data := createTempTestFile(t, fileSize)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	mediaID := "test_media_id"

	uploader.SetMediaID(mediaID)

	requestOptions := RequestOptions{
		Method:   "POST",
		Endpoint: MediaEndpoint + "/" + mediaID + "/append",
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	multipartOptions := MultipartOptions{
		RequestOptions: requestOptions,
		FormFields:     map[string]string{"segment_index": "0"},
		FileField:      "media",
		FileName:       filepath.Base(tempFile),
		FileData:       data[:4*1024*1024],
	}

	multipartOptions1 := MultipartOptions{
		RequestOptions: requestOptions,
		FormFields:     map[string]string{"segment_index": "1"},
		FileField:      "media",
		FileName:       filepath.Base(tempFile),
		FileData:       data[4*1024*1024:],
	}

	mockClient.On("SendMultipartRequest", multipartOptions).Return(json.RawMessage("{}"), nil)
	mockClient.On("SendMultipartRequest", multipartOptions1).Return(json.RawMessage("{}"), nil)

	err = uploader.Append()
	assert.NoError(t, err)

	mockClient.AssertExpectations(t)

	uploader.SetMediaID("")
	err = uploader.Append()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media ID not set")
}

func TestMediaUploader_Finalize(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	uploader.SetMediaID("test_media_id")

	finalizeResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"media_key": "test_media_key"
		}
	}`)

	expectedUrl := MediaEndpoint + fmt.Sprintf("/%s/finalize", uploader.GetMediaID())
	requestOptions := RequestOptions{
		Method:   "POST",
		Endpoint: expectedUrl,
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	mockClient.On("SendRequest", requestOptions).Return(finalizeResponse, nil)

	response, err := uploader.Finalize()
	assert.NoError(t, err)
	assert.Equal(t, finalizeResponse, response)

	mockClient.AssertExpectations(t)

	uploader.SetMediaID("")
	response, err = uploader.Finalize()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media ID not set")
	assert.Nil(t, response)
}

func TestMediaUploader_CheckStatus(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	uploader.SetMediaID("test_media_id")

	statusResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"media_key": "test_media_key",
			"processing_info": {
				"state": "succeeded",
				"progress_percent": 100
			}
		}
	}`)

	expectedUrl := MediaEndpoint + "?command=STATUS&media_id=test_media_id"
	requestOptions := RequestOptions{
		Method:   "GET",
		Endpoint: expectedUrl,
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	mockClient.On("SendRequest", requestOptions).Return(statusResponse, nil)

	response, err := uploader.CheckStatus()
	assert.NoError(t, err)
	assert.Equal(t, statusResponse, response)

	mockClient.AssertExpectations(t)

	uploader.SetMediaID("")
	response, err = uploader.CheckStatus()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media ID not set")
	assert.Nil(t, response)
}

func TestMediaUploader_WaitForProcessing(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	uploader, err := NewMediaUploader(mockClient, tempFile, false, false, "oauth2", "testuser", []string{})
	assert.NoError(t, err)

	uploader.SetMediaID("test_media_id")

	inProgressResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"media_key": "test_media_key",
			"processing_info": {
				"state": "in_progress",
				"check_after_secs": 1,
				"progress_percent": 50
			}
		}
	}`)

	successResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"media_key": "test_media_key",
			"processing_info": {
				"state": "succeeded",
				"progress_percent": 100
			}
		}
	}`)

	expectedUrl := MediaEndpoint + "?command=STATUS&media_id=test_media_id"

	requestOptions := RequestOptions{
		Method:   "GET",
		Endpoint: expectedUrl,
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	mockClient.On("SendRequest", requestOptions).Return(inProgressResponse, nil).Once()
	mockClient.On("SendRequest", requestOptions).Return(successResponse, nil).Once()

	response, err := uploader.WaitForProcessing()
	assert.NoError(t, err)
	assert.Equal(t, successResponse, response)

	mockClient.AssertExpectations(t)

	failedResponse := json.RawMessage(`{
		"data": {
			"id": "test_media_id",
			"media_key": "test_media_key",
			"processing_info": {
				"state": "failed",
				"progress_percent": 0
			}
		}
	}`)

	requestOptions = RequestOptions{
		Method:   "GET",
		Endpoint: expectedUrl,
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}

	mockClient.On("SendRequest", requestOptions).Return(failedResponse, nil).Once()

	response, err = uploader.WaitForProcessing()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media processing failed")
	assert.Nil(t, response)

	uploader.SetMediaID("")
	response, err = uploader.WaitForProcessing()
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media ID not set")
	assert.Nil(t, response)
}

func TestExecuteMediaUpload(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.URL.Path, MediaEndpoint) {
			command := ExtractCommand(r.URL.Path)

			switch command {
			case "initialize":
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(`{
					"data": {
						"id": "test_media_id",
						"expires_after_secs": 3600,
						"media_key": "test_media_key"
					}
				}`))
			case "append":
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(`{}`))
			case "finalize":
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(`{
					"data": {
						"id": "test_media_id",
						"media_key": "test_media_key"
					}
				}`))
			case "status":
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusOK)
				w.Write([]byte(`{
					"data": {
						"id": "test_media_id",
						"media_key": "test_media_key",
						"processing_info": {
							"state": "succeeded",
							"progress_percent": 100
						}
					}
				}`))
			default:
				w.WriteHeader(http.StatusBadRequest)
			}
		} else {
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	defer server.Close()

	client := &ApiClient{
		url:    server.URL,
		client: &http.Client{Timeout: 30 * time.Second},
	}

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	err := ExecuteMediaUpload(tempFile, "image/jpeg", "tweet_image", "oauth2", "testuser", false, false, false, []string{}, client)
	assert.NoError(t, err)

	err = ExecuteMediaUpload("nonexistent.txt", "image/jpeg", "tweet_image", "oauth2", "testuser", false, false, false, []string{}, client)
	assert.Error(t, err)
}

func TestExecuteMediaStatus(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == MediaEndpoint && r.URL.Query().Get("command") == "STATUS" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(`{
				"data": {
					"id": "test_media_id",
					"media_key": "test_media_key",
					"processing_info": {
						"state": "succeeded",
						"progress_percent": 100
					}
				}
			}`))
		} else {
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	defer server.Close()

	client := &ApiClient{
		url:    server.URL,
		client: &http.Client{Timeout: 30 * time.Second},
	}

	err := ExecuteMediaStatus("test_media_id", "oauth2", "testuser", false, false, false, []string{}, client)
	assert.NoError(t, err)
}

func TestExtractMediaID(t *testing.T) {
	testCases := []struct {
		url      string
		expected string
	}{
		{"/2/media/upload/123456/append", "123456"},
		{"/2/media/upload/123456/finalize", "123456"},
		{"/2/media/upload?command=STATUS&media_id=123456", "123456"},
		{"/2/media/upload/initialize", ""},
		{"/2/media/upload", ""},
		{"api.x.com/2/media/upload/123456/append", "123456"},
		{"api.x.com/2/media/upload/123456/finalize", "123456"},
		{"api.x.com/2/media/upload?command=STATUS&media_id=123456", "123456"},
		{"", ""},
	}

	for _, tc := range testCases {
		result := ExtractMediaID(tc.url)
		assert.Equal(t, tc.expected, result)
	}
}

func TestExtractSegmentIndex(t *testing.T) {
	testCases := []struct {
		url      string
		data     string
		expected string
	}{
		{"/2/media/upload/123/append", "", ""},
		{"/2/media/upload/123/append", "{\"segment_index\": \"1\"}", "1"},
	}

	for _, tc := range testCases {
		result := ExtractSegmentIndex(tc.data)
		assert.Equal(t, tc.expected, result)
	}
}

func TestIsMediaAppendRequest(t *testing.T) {
	testCases := []struct {
		url       string
		mediaFile string
		expected  bool
	}{
		{"/2/media/upload/123/append", "file.jpg", true},
		{"/2/media/upload/initialize", "file.jpg", false},
		{"/2/media/upload/123/append", "", false},
		{"/2/users/me", "file.jpg", false},
		{"", "", false},
	}

	for _, tc := range testCases {
		result := IsMediaAppendRequest(tc.url, tc.mediaFile)
		assert.Equal(t, tc.expected, result)
	}
}

func TestHandleMediaAppendRequest(t *testing.T) {
	mockClient := new(MockApiClient)

	tempFile, _ := createTempTestFile(t, 1024)
	defer os.Remove(tempFile)

	mockResponse := json.RawMessage(`{}`)

	url := "/2/media/upload/123456/append"
	requestOptions := RequestOptions{
		Method:   "POST",
		Endpoint: url,
		Headers:  []string{},
		Data:     "",
		AuthType: "oauth2",
		Username: "testuser",
		Verbose:  false,
	}
	multipartOptions := MultipartOptions{
		RequestOptions: requestOptions,
		FormFields:     map[string]string{"segment_index": "0"},
		FileField:      "media",
		FilePath:       tempFile,
		FileName:       filepath.Base(tempFile),
		FileData:       []byte{},
	}
	mockClient.On("SendMultipartRequest", multipartOptions).Return(mockResponse, nil).Twice()

	response, err := HandleMediaAppendRequest(requestOptions, tempFile, mockClient)
	assert.NoError(t, err)
	assert.Equal(t, mockResponse, response)

	response, err = HandleMediaAppendRequest(requestOptions, tempFile, mockClient)
	assert.NoError(t, err)
	assert.Equal(t, mockResponse, response)

	requestOptionsNoMediaID := requestOptions
	requestOptionsNoMediaID.Endpoint = "/2/media/upload?command=APPEND"
	response, err = HandleMediaAppendRequest(requestOptionsNoMediaID, tempFile, mockClient)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "media_id is required")
	assert.Nil(t, response)

	mockClient.AssertExpectations(t)
}