go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/web/negotiate_content_type_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package web

import (
	"fmt"
	"net/http"
	"testing"

	"go.charczuk.com/sdk/assert"
)

func Test_NegotiateContentType(t *testing.T) {
	testCases := [...]struct {
		s         string
		available []string
		expect    string
		expectErr error
	}{
		/* if no accept header, use first accepted result */
		{"", []string{"x/y", "foo/bar", "moo/loo"}, "x/y", nil},

		/* examples from rfc2616 */
		{"audio/*; q=0.2, audio/basic", []string{"audio/mp3", "audio/ogg-vorbis"}, "audio/mp3", nil},
		{"text/plain; q=0.5, text/html,text/x-dvi; q=0.8, text/x-c", []string{"text/html", "text/plain"}, "text/html", nil},
		{"text/*, text/html, text/html;level=1, */*", []string{"text/html", "text/plain"}, "text/html", nil},
		{"text/*, text/html, text/plain;level=1, */*", []string{"text/html", "text/plain"}, "text/html", nil},
		{"text/*, text/html, text/plain;level=1, */*", []string{"text/x-c", "text/html", "text/plain"}, "text/html", nil},

		/* test how q=0 interacts */
		{"text/html, */*;q=0", []string{"x/y"}, "", nil},
		{"text/html, */*;q=0", []string{"text/html"}, "text/html", nil},

		/* test wildcard matching */
		{"text/html, */*", []string{"x/y"}, "x/y", nil},
		{"text/html, text/*", []string{"text/plain"}, "text/plain", nil},

		/* test Not Acceptable results */
		{"text/html, image/png; q=0.4", []string{"foo/bar"}, "", nil},

		/* test matching order */
		{"text/html, image/png", []string{"text/html", "image/png"}, "text/html", nil},
		{"text/html, image/png", []string{"image/png", "text/html"}, "image/png", nil},
		{"text/html, image/png; q=0.4", []string{"image/png"}, "image/png", nil},
		{"text/html, image/png; q=0.4", []string{"text/html"}, "text/html", nil},
		{"text/html, image/png; q=0.4", []string{"image/png", "text/html"}, "text/html", nil},
		{"text/html, image/png; q=0.4", []string{"text/html", "image/png"}, "text/html", nil},
		{"text/html;q=0.4, image/png", []string{"image/png"}, "image/png", nil},
		{"text/html;q=0.4, image/png", []string{"text/html"}, "text/html", nil},
		{"text/html;q=0.4, image/png", []string{"image/png", "text/html"}, "image/png", nil},
		{"text/html;q=0.4, image/png", []string{"text/html", "image/png"}, "image/png", nil},
		{"image/png, image/*;q=0.4", []string{"image/jpg", "image/png"}, "image/png", nil},
		{"image/png, image/*;q=0.4", []string{"image/jpg"}, "image/jpg", nil},
		{"image/png, image/*;q=0.4", []string{"image/jpg", "image/gif"}, "image/jpg", nil},
		{"image/png, image/*", []string{"image/jpg", "image/gif"}, "image/jpg", nil},
		{"image/png, image/*", []string{"image/gif", "image/jpg"}, "image/gif", nil},
		{"image/png, image/*", []string{"image/gif", "image/png"}, "image/png", nil},
		{"image/png, image/*", []string{"image/png", "image/gif"}, "image/png", nil},

		/* test parsing errors */
		{",", nil, "", errNegotiateContentTypeAvailableEmpty},
		{",", []string{"text/html"}, "", errParseAcceptInvalidTag},
		{"foo*/bar", []string{"text/html"}, "", errParseAcceptInvalidTag},
		{"foo/bar", []string{"text/"}, "", errNegotiateContentTypeInvalidAvailableContentType},
		{"foo/bar", []string{"/html"}, "", errNegotiateContentTypeInvalidAvailableContentType},
	}

	for index, tt := range testCases {
		r := &http.Request{Header: http.Header{"Accept": {tt.s}}}
		actual, err := NegotiateContentType(r, tt.available...)
		if tt.expectErr != nil {
			assert.ItsNotNil(t, err, fmt.Sprintf("tc index: %d, input: %s", index, tt.s))
			assert.ItsEqual(t, tt.expectErr.Error(), err.Error(), fmt.Sprintf("tc index: %d, input: %s", index, tt.s))
		} else {
			assert.ItsNil(t, err, fmt.Sprintf("tc index: %d, input: %s", index, tt.s))
			assert.ItsEqual(t, tt.expect, actual, fmt.Sprintf("tc index: %d, input: %s", index, tt.s))
		}
	}
}

func Test_parseAccept(t *testing.T) {
	testCases := [...]struct {
		Input     string
		Expect    []acceptMediaType
		ExpectErr error
	}{
		/* empty case */
		{"", nil, nil},

		/* error cases */
		{",", nil, errParseAcceptInvalidTag},
		{"/", nil, fmt.Errorf("mime: no media type")},
		{"foo/", nil, fmt.Errorf("mime: expected token after slash")},
		{"/bar", nil, fmt.Errorf("mime: no media type")},
		{"foo//", nil, fmt.Errorf("mime: expected token after slash")},
		{"foo//*", nil, fmt.Errorf("mime: expected token after slash")},
		{"foo/bar/*", nil, fmt.Errorf("mime: unexpected content after media subtype")},
		{"*foo/bar", nil, errParseAcceptInvalidTag},
		{"foo/*bar", nil, errParseAcceptInvalidTag},
		{"foo abcd/bar", nil, fmt.Errorf("mime: expected slash after first token")},
		{"foo/bar abcd", nil, fmt.Errorf("mime: unexpected content after media subtype")},
		{"foo/bar;q=foo", nil, fmt.Errorf("strconv.ParseFloat: parsing \"foo\": invalid syntax")},
		{"foo/bar;level=foo", nil, fmt.Errorf("strconv.Atoi: parsing \"foo\": invalid syntax")},

		/* valid cases */
		{"text/html, image/png", []acceptMediaType{
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "image/png", Type: "image", Subtype: "png", Q: 1.0, RawParameters: map[string]string{}},
		}, nil},
		{"text/html,image/png", []acceptMediaType{
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "image/png", Type: "image", Subtype: "png", Q: 1.0, RawParameters: map[string]string{}},
		}, nil},
		{"text/html, image/*", []acceptMediaType{
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "image/*", Type: "image", Subtype: "*", Q: 1.0, RawParameters: map[string]string{}},
		}, nil},
		{"*/*, image/*", []acceptMediaType{
			{RawMediaType: "*/*", Type: "*", Subtype: "*", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "image/*", Type: "image", Subtype: "*", Q: 1.0, RawParameters: map[string]string{}},
		}, nil},
		{"image/png, text/html", []acceptMediaType{
			{RawMediaType: "image/png", Type: "image", Subtype: "png", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 1.0, RawParameters: map[string]string{}},
		}, nil},
		{"text/html, image/png; q=0.5", []acceptMediaType{
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 1.0, RawParameters: map[string]string{}},
			{RawMediaType: "image/png", Type: "image", Subtype: "png", Q: 0.5, RawParameters: map[string]string{"q": "0.5"}},
		}, nil},
		{"text/html; q=0.5; level=1, image/png; q=0.5", []acceptMediaType{
			{RawMediaType: "text/html", Type: "text", Subtype: "html", Q: 0.5, Level: 1, RawParameters: map[string]string{"q": "0.5", "level": "1"}},
			{RawMediaType: "image/png", Type: "image", Subtype: "png", Q: 0.5, RawParameters: map[string]string{"q": "0.5"}},
		}, nil},
	}

	for _, tc := range testCases {
		tags, err := parseAccept(tc.Input)
		if tc.ExpectErr != nil {
			assert.ItsNotNil(t, err)
			assert.ItsEqual(t, tc.ExpectErr.Error(), err.Error())
		} else {
			assert.ItsNil(t, err)
			assert.ItsEqual(t, tc.Expect, tags)
		}
	}
}

func Test_splitOn(t *testing.T) {
	testCases := [...]struct {
		Input          string
		Split          rune
		ExpectedBefore string
		ExpectedAfter  string
	}{
		{"", 0, "", ""},
		{"foo", rune('/'), "foo", ""},
		{"foo/", rune('/'), "foo", ""},
		{"foo/bar", rune('/'), "foo", "bar"},
		{"foo|bar", rune('/'), "foo|bar", ""},
		{"/bar", rune('/'), "", "bar"},
		{"//bar", rune('/'), "", "/bar"},
		{"/", rune('/'), "", ""},
		{"/bar", rune('/'), "", "bar"},
		{"foo/bar/baz", rune('/'), "foo", "bar/baz"},
		{"foo/bar//", rune('/'), "foo", "bar//"},
	}

	for _, tc := range testCases {
		before, after := splitOn(tc.Input, tc.Split)
		assert.ItsEqual(t, tc.ExpectedBefore, before, fmt.Sprintf("invalid before: %s", tc.Input))
		assert.ItsEqual(t, tc.ExpectedAfter, after, fmt.Sprintf("invalid after: %s", tc.Input))
	}
}