package idear

import "testing"

// The six spellings every AtLeast case below is drawn from: the three
// valid roles, plus three shapes an app might plausibly hand in — empty,
// upper-cased, and a made-up name — none of which is a role.
const (
	rOwner  = RoleOwner
	rAdmin  = RoleAdmin
	rMember = RoleMember
	rEmpty  = Role("")
	rUpper  = Role("OWNER")
	rBogus  = Role("root")
)

// TestRole_AtLeast enumerates every ordered pair of the six spellings
// above by hand. Each want is written down, not computed from rank() —
// a table that recomputes the implementation's own formula would only
// prove the formula equals itself.
func TestRole_AtLeast(t *testing.T) {
	cases := []struct {
		r, min Role
		want   bool
	}{
		// r = owner
		{rOwner, rOwner, true},
		{rOwner, rAdmin, true},
		{rOwner, rMember, true},
		{rOwner, rEmpty, false},
		{rOwner, rUpper, false},
		{rOwner, rBogus, false},

		// r = admin
		{rAdmin, rOwner, false},
		{rAdmin, rAdmin, true},
		{rAdmin, rMember, true},
		{rAdmin, rEmpty, false},
		{rAdmin, rUpper, false},
		{rAdmin, rBogus, false},

		// r = member
		{rMember, rOwner, false},
		{rMember, rAdmin, false},
		{rMember, rMember, true},
		{rMember, rEmpty, false},
		{rMember, rUpper, false},
		{rMember, rBogus, false},

		// r = "" (invalid) — false against every minimum, valid or not
		{rEmpty, rOwner, false},
		{rEmpty, rAdmin, false},
		{rEmpty, rMember, false},
		{rEmpty, rEmpty, false},
		{rEmpty, rUpper, false},
		{rEmpty, rBogus, false},

		// r = "OWNER" (invalid) — false against every minimum, valid or not
		{rUpper, rOwner, false},
		{rUpper, rAdmin, false},
		{rUpper, rMember, false},
		{rUpper, rEmpty, false},
		{rUpper, rUpper, false},
		{rUpper, rBogus, false},

		// r = "root" (invalid) — false against every minimum, valid or not
		{rBogus, rOwner, false},
		{rBogus, rAdmin, false},
		{rBogus, rMember, false},
		{rBogus, rEmpty, false},
		{rBogus, rUpper, false},
		{rBogus, rBogus, false},
	}

	if len(cases) != 36 {
		t.Fatalf("expected all 36 ordered pairs of 6 spellings, got %d", len(cases))
	}

	for _, c := range cases {
		got := c.r.AtLeast(c.min)
		if got != c.want {
			t.Errorf("Role(%q).AtLeast(%q) = %v, want %v", c.r, c.min, got, c.want)
		}
	}
}

func TestRole_Valid(t *testing.T) {
	cases := []struct {
		r    Role
		want bool
	}{
		{rOwner, true},
		{rAdmin, true},
		{rMember, true},
		{rEmpty, false},
		{rUpper, false},
		{rBogus, false},
	}
	for _, c := range cases {
		if got := c.r.Valid(); got != c.want {
			t.Errorf("Role(%q).Valid() = %v, want %v", c.r, got, c.want)
		}
	}
}

func TestRole_Title(t *testing.T) {
	cases := []struct {
		r    Role
		want string
	}{
		{rOwner, "Owner"},
		{rAdmin, "Admin"},
		{rMember, "Member"},
		{rEmpty, ""},
		{rUpper, ""},
		{rBogus, ""},
	}
	for _, c := range cases {
		if got := c.r.Title(); got != c.want {
			t.Errorf("Role(%q).Title() = %q, want %q", c.r, got, c.want)
		}
	}
}

func TestParseRole(t *testing.T) {
	accept := []struct {
		s    string
		want Role
	}{
		{"owner", RoleOwner},
		{"admin", RoleAdmin},
		{"member", RoleMember},
	}
	for _, c := range accept {
		got, ok := ParseRole(c.s)
		if !ok || got != c.want {
			t.Errorf("ParseRole(%q) = (%q, %v), want (%q, true)", c.s, got, ok, c.want)
		}
	}

	reject := []string{"", "OWNER", "root", "Owner"}
	for _, s := range reject {
		if got, ok := ParseRole(s); ok {
			t.Errorf("ParseRole(%q) = (%q, true), want ok=false", s, got)
		}
	}
}