parser_test.go

package httpparser

import (
	"net/http"
	"reflect"
	"strings"
	"testing"
)

func TestParseString(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		wantVars map[string]string
		want     []Request
	}{
		{
			name:  "single GET, no headers, no body",
			input: "GET https://example.com/health\n",
			want: []Request{
				{Method: "GET", URL: "https://example.com/health", Headers: http.Header{}, Line: 1},
			},
		},
		{
			name: "single POST with headers and JSON body",
			input: "POST https://example.com/users\n" +
				"Content-Type: application/json\n" +
				"Accept: application/json\n" +
				"\n" +
				"{\n  \"name\": \"Ada\"\n}\n",
			want: []Request{
				{
					Method: "POST",
					URL:    "https://example.com/users",
					Headers: http.Header{
						"Content-Type": {"application/json"},
						"Accept":       {"application/json"},
					},
					Body: []byte("{\n  \"name\": \"Ada\"\n}"),
					Line: 1,
				},
			},
		},
		{
			name: "multiple requests separated by ###",
			input: "GET https://example.com/a\n" +
				"###\n" +
				"DELETE https://example.com/b\n",
			want: []Request{
				{Method: "GET", URL: "https://example.com/a", Headers: http.Header{}, Line: 1},
				{Method: "DELETE", URL: "https://example.com/b", Headers: http.Header{}, Line: 3},
			},
		},
		{
			name: "file-level @var declarations",
			input: "@base = https://example.com\n" +
				"@token=xyz\n" +
				"\n" +
				"GET {{base}}/ping\n",
			wantVars: map[string]string{
				"base":  "https://example.com",
				"token": "xyz",
			},
			want: []Request{
				{Method: "GET", URL: "{{base}}/ping", Headers: http.Header{}, Line: 4},
			},
		},
		{
			name: "@name annotation sets Request.Name",
			input: "# @name fetchThing\n" +
				"GET https://example.com/thing\n",
			want: []Request{
				{Name: "fetchThing", Method: "GET", URL: "https://example.com/thing", Headers: http.Header{}, Line: 2},
			},
		},
		{
			name: "placeholders left intact in URL, headers, and body",
			input: "POST {{host}}/items/{{id}}\n" +
				"Authorization: Bearer {{token}}\n" +
				"\n" +
				"{\"value\": \"{{val}}\"}\n",
			want: []Request{
				{
					Method: "POST",
					URL:    "{{host}}/items/{{id}}",
					Headers: http.Header{
						"Authorization": {"Bearer {{token}}"},
					},
					Body: []byte("{\"value\": \"{{val}}\"}"),
					Line: 1,
				},
			},
		},
		{
			name: "comments ignored",
			input: "# a leading comment\n" +
				"// another comment\n" +
				"GET https://example.com/x\n" +
				"// header-region comment\n" +
				"X-Test: 1\n",
			want: []Request{
				{
					Method:  "GET",
					URL:     "https://example.com/x",
					Headers: http.Header{"X-Test": {"1"}},
					Line:    3,
				},
			},
		},
		{
			name:  "HTTP version accepted and ignored",
			input: "GET https://example.com/ver HTTP/1.1\n",
			want: []Request{
				{Method: "GET", URL: "https://example.com/ver", Headers: http.Header{}, Line: 1},
			},
		},
		{
			name:  "blank file returns empty File",
			input: "",
			want:  nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			f, err := ParseString(tt.input)
			if err != nil {
				t.Fatalf("ParseString returned error: %v", err)
			}

			wantVars := tt.wantVars
			if wantVars == nil {
				wantVars = map[string]string{}
			}
			if !reflect.DeepEqual(f.Vars, wantVars) {
				t.Errorf("Vars = %#v, want %#v", f.Vars, wantVars)
			}

			if !reflect.DeepEqual(f.Requests, tt.want) {
				t.Errorf("Requests = %#v, want %#v", f.Requests, tt.want)
			}
		})
	}
}

func TestParseMalformedRequestLine(t *testing.T) {
	// A method-less request line on line 3 must produce an error naming the line.
	input := "# comment\n" +
		"\n" +
		"NOTAMETHOD\n"
	_, err := ParseString(input)
	if err == nil {
		t.Fatal("expected error for malformed request line, got nil")
	}
	if !strings.Contains(err.Error(), "line 3") {
		t.Errorf("error = %q, want it to mention %q", err.Error(), "line 3")
	}
}

func TestParseUnsupportedMethod(t *testing.T) {
	_, err := ParseString("TRACE https://example.com/x\n")
	if err == nil {
		t.Fatal("expected error for unsupported method, got nil")
	}
	if !strings.Contains(err.Error(), "line 1") {
		t.Errorf("error = %q, want it to mention %q", err.Error(), "line 1")
	}
}

func TestParseFile(t *testing.T) {
	f, err := ParseFile("testdata/sample.http")
	if err != nil {
		t.Fatalf("ParseFile returned error: %v", err)
	}

	wantVars := map[string]string{
		"baseUrl": "https://api.example.com",
		"token":   "abc123",
	}
	if !reflect.DeepEqual(f.Vars, wantVars) {
		t.Errorf("Vars = %#v, want %#v", f.Vars, wantVars)
	}

	if len(f.Requests) != 2 {
		t.Fatalf("got %d requests, want 2", len(f.Requests))
	}

	get := f.Requests[0]
	if get.Name != "getUser" || get.Method != "GET" || get.URL != "{{baseUrl}}/users/1" {
		t.Errorf("first request = %+v", get)
	}
	if got := get.Headers.Get("Authorization"); got != "Bearer {{token}}" {
		t.Errorf("Authorization = %q, want %q", got, "Bearer {{token}}")
	}
	if get.Line != 5 {
		t.Errorf("first request Line = %d, want 5", get.Line)
	}

	post := f.Requests[1]
	if post.Name != "createUser" || post.Method != "POST" || post.URL != "{{baseUrl}}/users" {
		t.Errorf("second request = %+v", post)
	}
	if !strings.Contains(string(post.Body), "\"token\": \"{{token}}\"") {
		t.Errorf("second request body = %q", post.Body)
	}
}