params_test.go

package stripe_test

import (
	"net/url"
	"reflect"
	"testing"

	stripe "github.com/stripe/stripe-go"
	. "github.com/stripe/stripe-go/testing"
)

func TestCheckinRangeQueryParamsAppendTo(t *testing.T) {
	{
		values := &stripe.RequestValues{}

		// Try it with an empty set of parameters
		params := &stripe.RangeQueryParams{}
		params.AppendTo(values, "created")

		if !values.Empty() {
			t.Fatalf("Expected request values to be empty")
		}
	}

	{
		values := &stripe.RequestValues{}

		// Try it with an empty set of parameters
		params := &stripe.RangeQueryParams{
			GreaterThan:        10,
			GreaterThanOrEqual: 20,
			LesserThan:         30,
			LesserThanOrEqual:  40,
		}
		params.AppendTo(values, "created")

		{
			value := values.Get("created[gt]")
			if len(value) != 1 || value[0] != "10" {
				t.Fatalf(
					"Expected encoded value of 10 for created[gt] but got %v.",
					value)
			}
		}

		{
			value := values.Get("created[gte]")
			if len(value) != 1 || value[0] != "20" {
				t.Fatalf(
					"Expected encoded value of 10 for created[gte] but got %v.",
					value)
			}
		}

		{
			value := values.Get("created[lt]")
			if len(value) != 1 || value[0] != "30" {
				t.Fatalf(
					"Expected encoded value of 10 for created[lt] but got %v.",
					value)
			}
		}

		{
			value := values.Get("created[lte]")
			if len(value) != 1 || value[0] != "40" {
				t.Fatalf(
					"Expected encoded value of 10 for created[lte] but got %v.",
					value)
			}
		}
	}
}

func TestRequestValues(t *testing.T) {
	values := &stripe.RequestValues{}

	actual := values.Encode()
	expected := ""
	if expected != actual {
		t.Fatalf("Expected encoded value of %v but got %v.", expected, actual)
	}

	if !values.Empty() {
		t.Fatalf("Expected values to be empty.")
	}

	values = &stripe.RequestValues{}
	values.Add("foo", "bar")

	actual = values.Encode()
	expected = "foo=bar"
	if expected != actual {
		t.Fatalf("Expected encoded value of %v but got %v.", expected, actual)
	}

	if values.Empty() {
		t.Fatalf("Expected values to not be empty.")
	}

	got := values.Get("foo")
	if len(got) != 1 {
		t.Fatalf("Expected 1 result from Get, got %v.", len(got))
	}
	if got[0] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[0])
	}

	values = &stripe.RequestValues{}
	values.Add("foo", "bar")
	values.Add("foo", "bar")
	values.Add("baz", "bar")

	actual = values.Encode()
	expected = "foo=bar&foo=bar&baz=bar"
	if expected != actual {
		t.Fatalf("Expected encoded value of %v but got %v.", expected, actual)
	}

	got = values.Get("foo")
	if len(got) != 2 {
		t.Fatalf("Expected 2 results from Get, got %v.", len(got))
	}
	if got[0] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[0])
	}
	if got[1] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[1])
	}
	got = values.Get("baz")
	if len(got) != 1 {
		t.Fatalf("Expected 1 result from Get, got %v.", len(got))
	}
	if got[0] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[0])
	}

	values.Set("foo", "firstbar")

	actual = values.Encode()
	expected = "foo=firstbar&foo=bar&baz=bar"
	if expected != actual {
		t.Fatalf("Expected encoded value of %v but got %v.", expected, actual)
	}
	got = values.Get("foo")
	if len(got) != 2 {
		t.Fatalf("Expected 2 results from Get, got %v.", len(got))
	}
	if got[0] != "firstbar" {
		t.Fatalf("Expected 'firstbar' result from Get, got %v.", got[0])
	}
	if got[1] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[1])
	}
	got = values.Get("baz")
	if len(got) != 1 {
		t.Fatalf("Expected 1 result from Get, got %v.", len(got))
	}
	if got[0] != "bar" {
		t.Fatalf("Expected 'bar' result from Get, got %v.", got[0])
	}

	values.Set("new", "appended")

	actual = values.Encode()
	expected = "foo=firstbar&foo=bar&baz=bar&new=appended"
	if expected != actual {
		t.Fatalf("Expected encoded value of %v but got %v.", expected, actual)
	}

	urlValues := values.ToValues()
	expectedURLValues := url.Values{
		"baz": {"bar"},
		"foo": {"firstbar", "bar"},
		"new": {"appended"},
	}
	if !reflect.DeepEqual(urlValues, expectedURLValues) {
		t.Fatalf("Expected body of %v but got %v.", expectedURLValues, urlValues)
	}
	got = values.Get("new")
	if len(got) != 1 {
		t.Fatalf("Expected 1 result from Get, got %v.", len(got))
	}
	if got[0] != "appended" {
		t.Fatalf("Expected 'appended' result from Get, got %v.", got[0])
	}

	got = values.Get("boguskey")
	if got != nil {
		t.Fatalf("Expected nil, got %v", got)
	}
}

func TestParamsWithExtras(t *testing.T) {
	testCases := []struct {
		InitialBody  [][2]string
		Extras       [][2]string
		ExpectedBody [][2]string
	}{
		{
			InitialBody:  [][2]string{{"foo", "bar"}},
			Extras:       [][2]string{},
			ExpectedBody: [][2]string{{"foo", "bar"}},
		},
		{
			InitialBody:  [][2]string{{"foo", "bar"}},
			Extras:       [][2]string{{"foo", "baz"}, {"other", "thing"}},
			ExpectedBody: [][2]string{{"foo", "bar"}, {"foo", "baz"}, {"other", "thing"}},
		},
	}

	for _, testCase := range testCases {
		p := stripe.Params{}

		for _, extra := range testCase.Extras {
			p.AddExtra(extra[0], extra[1])
		}

		body := valuesFromArray(testCase.InitialBody)
		p.AppendTo(body)

		expected := valuesFromArray(testCase.ExpectedBody)
		if !reflect.DeepEqual(body, expected) {
			t.Fatalf("Expected body of %v but got %v.", expected, body)
		}
	}
}

func TestCheckinListParamsExpansion(t *testing.T) {
	testCases := []struct {
		InitialBody  [][2]string
		Expand       []string
		ExpectedBody [][2]string
	}{
		{
			InitialBody:  [][2]string{{"foo", "bar"}},
			Expand:       []string{},
			ExpectedBody: [][2]string{{"foo", "bar"}},
		},
		{
			InitialBody:  [][2]string{{"foo", "bar"}, {"foo", "baz"}},
			Expand:       []string{"data", "data.foo"},
			ExpectedBody: [][2]string{{"foo", "bar"}, {"foo", "baz"}, {"expand[]", "data"}, {"expand[]", "data.foo"}},
		},
	}

	for _, testCase := range testCases {
		p := stripe.ListParams{}

		for _, exp := range testCase.Expand {
			p.Expand(exp)
		}

		body := valuesFromArray(testCase.InitialBody)
		p.AppendTo(body)

		expected := valuesFromArray(testCase.ExpectedBody)
		if !reflect.DeepEqual(body, expected) {
			t.Fatalf("Expected body of %v but got %v.", expected, body)
		}
	}
}

func TestCheckinListParamsToParams(t *testing.T) {
	listParams := &stripe.ListParams{StripeAccount: TestMerchantID}
	params := listParams.ToParams()

	if params.StripeAccount != TestMerchantID {
		t.Fatalf("Expected StripeAccount of %v but got %v.",
			TestMerchantID, params.StripeAccount)
	}
}

func TestCheckinParamsSetAccount(t *testing.T) {
	p := &stripe.Params{}
	p.SetAccount(TestMerchantID)

	if p.Account != TestMerchantID {
		t.Fatalf("Expected Account of %v but got %v.", TestMerchantID, p.Account)
	}

	if p.StripeAccount != TestMerchantID {
		t.Fatalf("Expected StripeAccount of %v but got %v.", TestMerchantID, p.StripeAccount)
	}
}

func TestCheckinParamsSetStripeAccount(t *testing.T) {
	p := &stripe.Params{}
	p.SetStripeAccount(TestMerchantID)

	if p.StripeAccount != TestMerchantID {
		t.Fatalf("Expected Account of %v but got %v.", TestMerchantID, p.StripeAccount)
	}

	// Check that we don't set the deprecated parameter.
	if p.Account != "" {
		t.Fatalf("Expected empty Account but got %v.", TestMerchantID)
	}
}

// Converts a collection of key/value tuples in a two dimensional slice/array
// into RequestValues form. The purpose of this is that it's much cleaner to
// initialize the array all at once on a single line.
func valuesFromArray(arr [][2]string) *stripe.RequestValues {
	body := &stripe.RequestValues{}
	for _, v := range arr {
		body.Add(v[0], v[1])
	}
	return body
}