package ldap

import (
	"testing"

	"github.com/ps78674/goldap/message"
)

func TestBuildBleveQuery(t *testing.T) {
	s := &server{l: testLogger()}

	cases := []struct {
		name   string
		filter message.Filter
		want   string
	}{
		{
			name:   "equality on uid",
			filter: berEqualityFilter(t, "uid", "jsmith"),
			want:   `ID:"jsmith"`,
		},
		{
			name:   "equality on cn",
			filter: berEqualityFilter(t, "cn", "admins"),
			want:   `Name:"admins"`,
		},
		{
			name:   "attribute present",
			filter: berPresentFilter(t, "uid"),
			want:   "ID:*",
		},
		{
			name: "or of two matches",
			filter: berOrFilter(t,
				berRawEquality("uid", "jsmith"),
				berRawEquality("uid", "jdoe"),
			),
			want: `ID:"jsmith" ID:"jdoe"`,
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := s.buildBleveQuery(tc.filter)
			if err != nil {
				t.Fatalf("unexpected error: %s", err)
			}
			if got != tc.want {
				t.Errorf("got %q, want %q", got, tc.want)
			}
		})
	}
}

// Assertion values are parsed by Bleve, so they must not be able to
// introduce extra query terms or operators.
func TestBuildBleveQueryEscapesValues(t *testing.T) {
	s := &server{l: testLogger()}

	cases := []struct {
		value string
		want  string
	}{
		{"x Name:y", `ID:"x Name:y"`},
		{`x" OR ID:"*`, `ID:"x\" OR ID:\"*"`},
		{`back\slash`, `ID:"back\\slash"`},
		{"x AND Name:admin", `ID:"x AND Name:admin"`},
	}
	for _, tc := range cases {
		got, err := s.buildBleveQuery(berEqualityFilter(t, "uid", tc.value))
		if err != nil {
			t.Fatalf("%q: unexpected error: %s", tc.value, err)
		}
		if got != tc.want {
			t.Errorf("value %q: got %q, want %q", tc.value, got, tc.want)
		}
	}
}

func TestBuildBleveQueryUnsupported(t *testing.T) {
	s := &server{l: testLogger()}

	if _, err := s.buildBleveQuery(berPresentFilter(t, "mail")); err == nil {
		t.Error("an unsupported attribute should not produce a query")
	}
}