initital

Author: janstuemmel

.github/workflows/test.yaml

@@ -0,0 +1,13 @@
+name: Test
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test_unit:
+    name: Unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - run: go test -v

.gitignore

@@ -0,0 +1 @@
+.vscode

README.md

@@ -0,0 +1,23 @@
+# LDAP filter
+
+A work-in-progress [RFC4515](https://datatracker.ietf.org/doc/html/rfc4515) ldap filter parser
+
+Only a few filters are implemented at the moment (And, Or, Equality)
+
+## Usage
+
+```go
+import "github.com/janstuemmel/go-ldap-filter"
+
+filter, err := ldapfilter.NewParser("|(name=Jon)(name=Foo)").Parse()
+
+if err != nil {
+  panic(err)
+}
+
+ok := filter.Match(map[string][]string{
+  "name": {"Jon"}
+})
+
+fmt.Println(ok)
+```

go.mod

@@ -0,0 +1,3 @@
+module github.com/janstuemmel/go-ldap-filter
+
+go 1.18

go.sum

@@ -0,0 +1,95 @@
+package ldapfilter
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestFilterAnd(t *testing.T) {
+	input := Input{
+		"foo": {"bar", "baz"},
+	}
+	filter := AndFilter{}
+	filter.Append(&AndFilter{})
+	res := filter.Match(input)
+	assert(t, true, res)
+}
+
+func TestFilterOr(t *testing.T) {
+	input := Input{
+		"foo": {"bar", "baz"},
+	}
+	filter := &OrFilter{
+		Children: []Filter{
+			&AndFilter{},
+			&AndFilter{},
+		},
+	}
+	res := filter.Match(input)
+	assert(t, true, res)
+}
+
+func TestFilterEquality(t *testing.T) {
+	filter := EqualityFilter{
+		Key:   "foo",
+		Value: "baz",
+	}
+
+	t.Run("should match", func(t *testing.T) {
+		input := Input{
+			"foo": {"bar", "baz"},
+		}
+		res := filter.Match(input)
+		assert(t, true, res)
+	})
+
+	t.Run("should not match", func(t *testing.T) {
+		input := Input{
+			"foo": {"bar"},
+		}
+		res := filter.Match(input)
+		assert(t, false, res)
+	})
+}
+
+func TestFilter(t *testing.T) {
+
+	testData := []struct {
+		expr string
+		ok   bool
+		inp  Input
+	}{
+		{
+			expr: "(name=Jon)",
+			inp:  Input{"name": {"Jon"}},
+			ok:   true,
+		},
+		{
+			expr: "|(name=Jon)(name=Foo)",
+			inp:  Input{"name": {"Jon"}},
+			ok:   true,
+		},
+		{
+			expr: "|(name=Jon)(alt=Foo)",
+			inp:  Input{"alt": {"Foo"}},
+			ok:   true,
+		},
+	}
+
+	for _, test := range testData {
+		t.Run("", func(t *testing.T) {
+			filter, err := NewParser(test.expr).Parse()
+			assert(t, nil, err)
+			assert(t, test.ok, filter.Match(test.inp))
+		})
+	}
+}
+
+// helper
+
+func assert(t *testing.T, want interface{}, have interface{}) {
+	t.Helper()
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("Assertion failed for %s\n\twant:\t%+v\n\thave:\t%+v", t.Name(), want, have)
+	}
+}

ladapfilter_test.go

@@ -0,0 +1,84 @@
+package ldapfilter
+
+type Input = map[string][]interface{}
+
+type Filter interface {
+	Match(input Input) bool
+	Append(filter Filter)
+}
+
+// AND
+
+type AndFilter struct {
+	Type     string
+	Children []Filter
+}
+
+func NewAndFilter() *AndFilter {
+	return &AndFilter{Type: "and"}
+}
+
+func (f *AndFilter) Match(input Input) bool {
+	for _, filter := range f.Children {
+		if !filter.Match(input) {
+			return false
+		}
+	}
+	return true
+}
+
+func (f *AndFilter) Append(filter Filter) {
+	f.Children = append(f.Children, filter)
+}
+
+// OR
+
+type OrFilter struct {
+	Type     string
+	Children []Filter
+}
+
+func NewOrFilter() *OrFilter {
+	return &OrFilter{Type: "or"}
+}
+
+func (f *OrFilter) Match(input Input) bool {
+	if len(f.Children) == 0 {
+		return true
+	}
+	for _, filter := range f.Children {
+		if filter.Match(input) {
+			return true
+		}
+	}
+	return false
+}
+
+func (f *OrFilter) Append(filter Filter) {
+	f.Children = append(f.Children, filter)
+}
+
+// EQUALITY
+
+type EqualityFilter struct {
+	Type  string
+	Key   string
+	Value string
+}
+
+func NewEqualityFilter() *EqualityFilter {
+	return &EqualityFilter{Type: "equality"}
+}
+
+func (f *EqualityFilter) Match(input Input) bool {
+	if values, ok := input[f.Key]; ok {
+		for _, value := range values {
+			if value == f.Value {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (f *EqualityFilter) Append(filter Filter) {}