package acl

import (
	"testing"
)

func TestRootACL(t *testing.T) {
	if RootACL("allow") != AllowAll() {
		t.Fatalf("Bad root")
	}
	if RootACL("deny") != DenyAll() {
		t.Fatalf("Bad root")
	}
	if RootACL("manage") != ManageAll() {
		t.Fatalf("Bad root")
	}
	if RootACL("foo") != nil {
		t.Fatalf("bad root")
	}
}

func TestStaticACL(t *testing.T) {
	all := AllowAll()
	if _, ok := all.(*StaticACL); !ok {
		t.Fatalf("expected static")
	}

	none := DenyAll()
	if _, ok := none.(*StaticACL); !ok {
		t.Fatalf("expected static")
	}

	manage := ManageAll()
	if _, ok := manage.(*StaticACL); !ok {
		t.Fatalf("expected static")
	}

	if all.ACLList() {
		t.Fatalf("should not allow")
	}
	if all.ACLModify() {
		t.Fatalf("should not allow")
	}
	if !all.AgentRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.AgentWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !all.EventRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.EventWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !all.KeyRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.KeyWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !all.KeyringRead() {
		t.Fatalf("should allow")
	}
	if !all.KeyringWrite() {
		t.Fatalf("should allow")
	}
	if !all.NodeRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.NodeWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !all.OperatorRead() {
		t.Fatalf("should allow")
	}
	if !all.OperatorWrite() {
		t.Fatalf("should allow")
	}
	if !all.PreparedQueryRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.PreparedQueryWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !all.ServiceRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.ServiceWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !all.SessionRead("foobar") {
		t.Fatalf("should allow")
	}
	if !all.SessionWrite("foobar") {
		t.Fatalf("should allow")
	}
	if all.Snapshot() {
		t.Fatalf("should not allow")
	}

	if none.ACLList() {
		t.Fatalf("should not allow")
	}
	if none.ACLModify() {
		t.Fatalf("should not allow")
	}
	if none.AgentRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.AgentWrite("foobar") {
		t.Fatalf("should not allow")
	}
	if none.EventRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.EventRead("") {
		t.Fatalf("should not allow")
	}
	if none.EventWrite("foobar") {
		t.Fatalf("should not allow")
	}
	if none.EventWrite("") {
		t.Fatalf("should not allow")
	}
	if none.KeyRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.KeyWrite("foobar", nil) {
		t.Fatalf("should not allow")
	}
	if none.KeyringRead() {
		t.Fatalf("should now allow")
	}
	if none.KeyringWrite() {
		t.Fatalf("should not allow")
	}
	if none.NodeRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.NodeWrite("foobar", nil) {
		t.Fatalf("should not allow")
	}
	if none.OperatorRead() {
		t.Fatalf("should now allow")
	}
	if none.OperatorWrite() {
		t.Fatalf("should not allow")
	}
	if none.PreparedQueryRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.PreparedQueryWrite("foobar") {
		t.Fatalf("should not allow")
	}
	if none.ServiceRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.ServiceWrite("foobar", nil) {
		t.Fatalf("should not allow")
	}
	if none.SessionRead("foobar") {
		t.Fatalf("should not allow")
	}
	if none.SessionWrite("foobar") {
		t.Fatalf("should not allow")
	}
	if none.Snapshot() {
		t.Fatalf("should not allow")
	}

	if !manage.ACLList() {
		t.Fatalf("should allow")
	}
	if !manage.ACLModify() {
		t.Fatalf("should allow")
	}
	if !manage.AgentRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.AgentWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.EventRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.EventWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.KeyRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.KeyWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !manage.KeyringRead() {
		t.Fatalf("should allow")
	}
	if !manage.KeyringWrite() {
		t.Fatalf("should allow")
	}
	if !manage.NodeRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.NodeWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !manage.OperatorRead() {
		t.Fatalf("should allow")
	}
	if !manage.OperatorWrite() {
		t.Fatalf("should allow")
	}
	if !manage.PreparedQueryRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.PreparedQueryWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.ServiceRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.ServiceWrite("foobar", nil) {
		t.Fatalf("should allow")
	}
	if !manage.SessionRead("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.SessionWrite("foobar") {
		t.Fatalf("should allow")
	}
	if !manage.Snapshot() {
		t.Fatalf("should allow")
	}
}

func TestPolicyACL(t *testing.T) {
	all := AllowAll()
	policy := &Policy{
		Events: []*EventPolicy{
			&EventPolicy{
				Event:  "",
				Policy: PolicyRead,
			},
			&EventPolicy{
				Event:  "foo",
				Policy: PolicyWrite,
			},
			&EventPolicy{
				Event:  "bar",
				Policy: PolicyDeny,
			},
		},
		Keys: []*KeyPolicy{
			&KeyPolicy{
				Prefix: "foo/",
				Policy: PolicyWrite,
			},
			&KeyPolicy{
				Prefix: "foo/priv/",
				Policy: PolicyDeny,
			},
			&KeyPolicy{
				Prefix: "bar/",
				Policy: PolicyDeny,
			},
			&KeyPolicy{
				Prefix: "zip/",
				Policy: PolicyRead,
			},
		},
		PreparedQueries: []*PreparedQueryPolicy{
			&PreparedQueryPolicy{
				Prefix: "",
				Policy: PolicyRead,
			},
			&PreparedQueryPolicy{
				Prefix: "foo",
				Policy: PolicyWrite,
			},
			&PreparedQueryPolicy{
				Prefix: "bar",
				Policy: PolicyDeny,
			},
			&PreparedQueryPolicy{
				Prefix: "zoo",
				Policy: PolicyWrite,
			},
		},
		Services: []*ServicePolicy{
			&ServicePolicy{
				Name:   "",
				Policy: PolicyWrite,
			},
			&ServicePolicy{
				Name:   "foo",
				Policy: PolicyRead,
			},
			&ServicePolicy{
				Name:   "bar",
				Policy: PolicyDeny,
			},
			&ServicePolicy{
				Name:   "barfoo",
				Policy: PolicyWrite,
			},
		},
	}
	acl, err := New(all, policy, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	type keycase struct {
		inp         string
		read        bool
		write       bool
		writePrefix bool
	}
	cases := []keycase{
		{"other", true, true, true},
		{"foo/test", true, true, true},
		{"foo/priv/test", false, false, false},
		{"bar/any", false, false, false},
		{"zip/test", true, false, false},
		{"foo/", true, true, false},
		{"", true, true, false},
	}
	for _, c := range cases {
		if c.read != acl.KeyRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.KeyWrite(c.inp, nil) {
			t.Fatalf("Write fail: %#v", c)
		}
		if c.writePrefix != acl.KeyWritePrefix(c.inp) {
			t.Fatalf("Write prefix fail: %#v", c)
		}
	}

	// Test the services
	type servicecase struct {
		inp   string
		read  bool
		write bool
	}
	scases := []servicecase{
		{"other", true, true},
		{"foo", true, false},
		{"bar", false, false},
		{"foobar", true, false},
		{"barfo", false, false},
		{"barfoo", true, true},
		{"barfoo2", true, true},
	}
	for _, c := range scases {
		if c.read != acl.ServiceRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.ServiceWrite(c.inp, nil) {
			t.Fatalf("Write fail: %#v", c)
		}
	}

	// Test the events
	type eventcase struct {
		inp   string
		read  bool
		write bool
	}
	eventcases := []eventcase{
		{"foo", true, true},
		{"foobar", true, true},
		{"bar", false, false},
		{"barbaz", false, false},
		{"baz", true, false},
	}
	for _, c := range eventcases {
		if c.read != acl.EventRead(c.inp) {
			t.Fatalf("Event fail: %#v", c)
		}
		if c.write != acl.EventWrite(c.inp) {
			t.Fatalf("Event fail: %#v", c)
		}
	}

	// Test prepared queries
	type querycase struct {
		inp   string
		read  bool
		write bool
	}
	querycases := []querycase{
		{"foo", true, true},
		{"foobar", true, true},
		{"bar", false, false},
		{"barbaz", false, false},
		{"baz", true, false},
		{"nope", true, false},
		{"zoo", true, true},
		{"zookeeper", true, true},
	}
	for _, c := range querycases {
		if c.read != acl.PreparedQueryRead(c.inp) {
			t.Fatalf("Prepared query fail: %#v", c)
		}
		if c.write != acl.PreparedQueryWrite(c.inp) {
			t.Fatalf("Prepared query fail: %#v", c)
		}
	}
}

func TestPolicyACL_Parent(t *testing.T) {
	deny := DenyAll()
	policyRoot := &Policy{
		Keys: []*KeyPolicy{
			&KeyPolicy{
				Prefix: "foo/",
				Policy: PolicyWrite,
			},
			&KeyPolicy{
				Prefix: "bar/",
				Policy: PolicyRead,
			},
		},
		PreparedQueries: []*PreparedQueryPolicy{
			&PreparedQueryPolicy{
				Prefix: "other",
				Policy: PolicyWrite,
			},
			&PreparedQueryPolicy{
				Prefix: "foo",
				Policy: PolicyRead,
			},
		},
		Services: []*ServicePolicy{
			&ServicePolicy{
				Name:   "other",
				Policy: PolicyWrite,
			},
			&ServicePolicy{
				Name:   "foo",
				Policy: PolicyRead,
			},
		},
	}
	root, err := New(deny, policyRoot, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	policy := &Policy{
		Keys: []*KeyPolicy{
			&KeyPolicy{
				Prefix: "foo/priv/",
				Policy: PolicyRead,
			},
			&KeyPolicy{
				Prefix: "bar/",
				Policy: PolicyDeny,
			},
			&KeyPolicy{
				Prefix: "zip/",
				Policy: PolicyRead,
			},
		},
		PreparedQueries: []*PreparedQueryPolicy{
			&PreparedQueryPolicy{
				Prefix: "bar",
				Policy: PolicyDeny,
			},
		},
		Services: []*ServicePolicy{
			&ServicePolicy{
				Name:   "bar",
				Policy: PolicyDeny,
			},
		},
	}
	acl, err := New(root, policy, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	type keycase struct {
		inp         string
		read        bool
		write       bool
		writePrefix bool
	}
	cases := []keycase{
		{"other", false, false, false},
		{"foo/test", true, true, true},
		{"foo/priv/test", true, false, false},
		{"bar/any", false, false, false},
		{"zip/test", true, false, false},
	}
	for _, c := range cases {
		if c.read != acl.KeyRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.KeyWrite(c.inp, nil) {
			t.Fatalf("Write fail: %#v", c)
		}
		if c.writePrefix != acl.KeyWritePrefix(c.inp) {
			t.Fatalf("Write prefix fail: %#v", c)
		}
	}

	// Test the services
	type servicecase struct {
		inp   string
		read  bool
		write bool
	}
	scases := []servicecase{
		{"fail", false, false},
		{"other", true, true},
		{"foo", true, false},
		{"bar", false, false},
	}
	for _, c := range scases {
		if c.read != acl.ServiceRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.ServiceWrite(c.inp, nil) {
			t.Fatalf("Write fail: %#v", c)
		}
	}

	// Test prepared queries
	type querycase struct {
		inp   string
		read  bool
		write bool
	}
	querycases := []querycase{
		{"foo", true, false},
		{"foobar", true, false},
		{"bar", false, false},
		{"barbaz", false, false},
		{"baz", false, false},
		{"nope", false, false},
	}
	for _, c := range querycases {
		if c.read != acl.PreparedQueryRead(c.inp) {
			t.Fatalf("Prepared query fail: %#v", c)
		}
		if c.write != acl.PreparedQueryWrite(c.inp) {
			t.Fatalf("Prepared query fail: %#v", c)
		}
	}

	// Check some management functions that chain up
	if acl.ACLList() {
		t.Fatalf("should not allow")
	}
	if acl.ACLModify() {
		t.Fatalf("should not allow")
	}
	if acl.Snapshot() {
		t.Fatalf("should not allow")
	}
}

func TestPolicyACL_Agent(t *testing.T) {
	deny := DenyAll()
	policyRoot := &Policy{
		Agents: []*AgentPolicy{
			&AgentPolicy{
				Node:   "root-nope",
				Policy: PolicyDeny,
			},
			&AgentPolicy{
				Node:   "root-ro",
				Policy: PolicyRead,
			},
			&AgentPolicy{
				Node:   "root-rw",
				Policy: PolicyWrite,
			},
			&AgentPolicy{
				Node:   "override",
				Policy: PolicyDeny,
			},
		},
	}
	root, err := New(deny, policyRoot, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	policy := &Policy{
		Agents: []*AgentPolicy{
			&AgentPolicy{
				Node:   "child-nope",
				Policy: PolicyDeny,
			},
			&AgentPolicy{
				Node:   "child-ro",
				Policy: PolicyRead,
			},
			&AgentPolicy{
				Node:   "child-rw",
				Policy: PolicyWrite,
			},
			&AgentPolicy{
				Node:   "override",
				Policy: PolicyWrite,
			},
		},
	}
	acl, err := New(root, policy, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	type agentcase struct {
		inp   string
		read  bool
		write bool
	}
	cases := []agentcase{
		{"nope", false, false},
		{"root-nope", false, false},
		{"root-ro", true, false},
		{"root-rw", true, true},
		{"root-nope-prefix", false, false},
		{"root-ro-prefix", true, false},
		{"root-rw-prefix", true, true},
		{"child-nope", false, false},
		{"child-ro", true, false},
		{"child-rw", true, true},
		{"child-nope-prefix", false, false},
		{"child-ro-prefix", true, false},
		{"child-rw-prefix", true, true},
		{"override", true, true},
	}
	for _, c := range cases {
		if c.read != acl.AgentRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.AgentWrite(c.inp) {
			t.Fatalf("Write fail: %#v", c)
		}
	}
}

func TestPolicyACL_Keyring(t *testing.T) {
	type keyringcase struct {
		inp   string
		read  bool
		write bool
	}
	cases := []keyringcase{
		{"", false, false},
		{PolicyRead, true, false},
		{PolicyWrite, true, true},
		{PolicyDeny, false, false},
	}
	for _, c := range cases {
		acl, err := New(DenyAll(), &Policy{Keyring: c.inp}, nil)
		if err != nil {
			t.Fatalf("bad: %s", err)
		}
		if acl.KeyringRead() != c.read {
			t.Fatalf("bad: %#v", c)
		}
		if acl.KeyringWrite() != c.write {
			t.Fatalf("bad: %#v", c)
		}
	}
}

func TestPolicyACL_Operator(t *testing.T) {
	type operatorcase struct {
		inp   string
		read  bool
		write bool
	}
	cases := []operatorcase{
		{"", false, false},
		{PolicyRead, true, false},
		{PolicyWrite, true, true},
		{PolicyDeny, false, false},
	}
	for _, c := range cases {
		acl, err := New(DenyAll(), &Policy{Operator: c.inp}, nil)
		if err != nil {
			t.Fatalf("bad: %s", err)
		}
		if acl.OperatorRead() != c.read {
			t.Fatalf("bad: %#v", c)
		}
		if acl.OperatorWrite() != c.write {
			t.Fatalf("bad: %#v", c)
		}
	}
}

func TestPolicyACL_Node(t *testing.T) {
	deny := DenyAll()
	policyRoot := &Policy{
		Nodes: []*NodePolicy{
			&NodePolicy{
				Name:   "root-nope",
				Policy: PolicyDeny,
			},
			&NodePolicy{
				Name:   "root-ro",
				Policy: PolicyRead,
			},
			&NodePolicy{
				Name:   "root-rw",
				Policy: PolicyWrite,
			},
			&NodePolicy{
				Name:   "override",
				Policy: PolicyDeny,
			},
		},
	}
	root, err := New(deny, policyRoot, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	policy := &Policy{
		Nodes: []*NodePolicy{
			&NodePolicy{
				Name:   "child-nope",
				Policy: PolicyDeny,
			},
			&NodePolicy{
				Name:   "child-ro",
				Policy: PolicyRead,
			},
			&NodePolicy{
				Name:   "child-rw",
				Policy: PolicyWrite,
			},
			&NodePolicy{
				Name:   "override",
				Policy: PolicyWrite,
			},
		},
	}
	acl, err := New(root, policy, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	type nodecase struct {
		inp   string
		read  bool
		write bool
	}
	cases := []nodecase{
		{"nope", false, false},
		{"root-nope", false, false},
		{"root-ro", true, false},
		{"root-rw", true, true},
		{"root-nope-prefix", false, false},
		{"root-ro-prefix", true, false},
		{"root-rw-prefix", true, true},
		{"child-nope", false, false},
		{"child-ro", true, false},
		{"child-rw", true, true},
		{"child-nope-prefix", false, false},
		{"child-ro-prefix", true, false},
		{"child-rw-prefix", true, true},
		{"override", true, true},
	}
	for _, c := range cases {
		if c.read != acl.NodeRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.NodeWrite(c.inp, nil) {
			t.Fatalf("Write fail: %#v", c)
		}
	}
}

func TestPolicyACL_Session(t *testing.T) {
	deny := DenyAll()
	policyRoot := &Policy{
		Sessions: []*SessionPolicy{
			&SessionPolicy{
				Node:   "root-nope",
				Policy: PolicyDeny,
			},
			&SessionPolicy{
				Node:   "root-ro",
				Policy: PolicyRead,
			},
			&SessionPolicy{
				Node:   "root-rw",
				Policy: PolicyWrite,
			},
			&SessionPolicy{
				Node:   "override",
				Policy: PolicyDeny,
			},
		},
	}
	root, err := New(deny, policyRoot, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	policy := &Policy{
		Sessions: []*SessionPolicy{
			&SessionPolicy{
				Node:   "child-nope",
				Policy: PolicyDeny,
			},
			&SessionPolicy{
				Node:   "child-ro",
				Policy: PolicyRead,
			},
			&SessionPolicy{
				Node:   "child-rw",
				Policy: PolicyWrite,
			},
			&SessionPolicy{
				Node:   "override",
				Policy: PolicyWrite,
			},
		},
	}
	acl, err := New(root, policy, nil)
	if err != nil {
		t.Fatalf("err: %v", err)
	}

	type sessioncase struct {
		inp   string
		read  bool
		write bool
	}
	cases := []sessioncase{
		{"nope", false, false},
		{"root-nope", false, false},
		{"root-ro", true, false},
		{"root-rw", true, true},
		{"root-nope-prefix", false, false},
		{"root-ro-prefix", true, false},
		{"root-rw-prefix", true, true},
		{"child-nope", false, false},
		{"child-ro", true, false},
		{"child-rw", true, true},
		{"child-nope-prefix", false, false},
		{"child-ro-prefix", true, false},
		{"child-rw-prefix", true, true},
		{"override", true, true},
	}
	for _, c := range cases {
		if c.read != acl.SessionRead(c.inp) {
			t.Fatalf("Read fail: %#v", c)
		}
		if c.write != acl.SessionWrite(c.inp) {
			t.Fatalf("Write fail: %#v", c)
		}
	}
}