fix: Filters from list and regex both match (#2)

Signed-off-by: Julien Riou <julien@riou.xyz>

base/config.go

@@ -141,6 +141,18 @@ func (c *Config) CompileRegexes() (err error) {
 			return err
 		}
 	}
+	if c.IncludeDatabasesRegex != "" {
+		c.IncludeDatabasesRegexCompiled, err = regexp.Compile(c.IncludeDatabasesRegex)
+		if err != nil {
+			return err
+		}
+	}
+	if c.ExcludeDatabasesRegex != "" {
+		c.ExcludeDatabasesRegexCompiled, err = regexp.Compile(c.ExcludeDatabasesRegex)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 

base/session.go

@@ -60,3 +60,21 @@ func (s *Session) IsIdle() bool {
 	}
 	return false
 }
+
+// Equal returns true when two sessions share the same process id
+func (s *Session) Equal(session *Session) bool {
+	if s.Pid == 0 {
+		return s.User == session.User && s.Db == session.Db && s.Client == session.Client
+	}
+	return s.Pid == session.Pid
+}
+
+// InSlice returns true when this sessions in present in the slice
+func (s *Session) InSlice(sessions []*Session) bool {
+	for _, session := range sessions {
+		if s.Equal(session) {
+			return true
+		}
+	}
+	return false
+}

base/session_test.go

@@ -0,0 +1,139 @@
+package base
+
+import (
+	"testing"
+)
+
+func TestSessionEqual(t *testing.T) {
+	tests := []struct {
+		name   string
+		first  *Session
+		second *Session
+		want   bool
+	}{
+		{
+			"Empty sessions",
+			&Session{},
+			&Session{},
+			true,
+		},
+		{
+			"Identical process id",
+			&Session{Pid: 1},
+			&Session{Pid: 1},
+			true,
+		},
+		{
+			"Different process id",
+			&Session{Pid: 1},
+			&Session{Pid: 2},
+			false,
+		},
+		{
+			"Identical users",
+			&Session{User: "test"},
+			&Session{User: "test"},
+			true,
+		},
+		{
+			"Different users",
+			&Session{User: "test"},
+			&Session{User: "random"},
+			false,
+		},
+		{
+			"Identical databases",
+			&Session{Db: "test"},
+			&Session{Db: "test"},
+			true,
+		},
+		{
+			"Different databases",
+			&Session{Db: "test"},
+			&Session{Db: "random"},
+			false,
+		},
+		{
+			"Identical users and databases",
+			&Session{User: "test", Db: "test"},
+			&Session{User: "test", Db: "test"},
+			true,
+		},
+		{
+			"Different users and same databases",
+			&Session{User: "test_1", Db: "test"},
+			&Session{User: "test_2", Db: "test"},
+			false,
+		},
+		{
+			"Different databases and same user",
+			&Session{User: "test", Db: "test_1"},
+			&Session{User: "test", Db: "test_2"},
+			false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := tc.first.Equal(tc.second)
+			if got != tc.want {
+				t.Errorf("got %t; want %t", got, tc.want)
+			} else {
+				t.Logf("got %t; want %t", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestSessionInSlice(t *testing.T) {
+	sessions := []*Session{
+		{User: "test"},
+		{User: "test_1"},
+		{User: "test_2"},
+		{User: "postgres"},
+		{Db: "test"},
+	}
+
+	tests := []struct {
+		name  string
+		input *Session
+		want  bool
+	}{
+		{
+			"Empty session",
+			&Session{},
+			false,
+		},
+		{
+			"Session with user in slice",
+			&Session{User: "test"},
+			true,
+		},
+		{
+			"Session with user not in slice",
+			&Session{User: "random"},
+			false,
+		},
+		{
+			"Session with db in slice",
+			&Session{Db: "test"},
+			true,
+		},
+		{
+			"Session with db not in slice",
+			&Session{Db: "random"},
+			false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := tc.input.InSlice(sessions)
+			if got != tc.want {
+				t.Errorf("got %t; want %t", got, tc.want)
+			} else {
+				t.Logf("got %t; want %t", got, tc.want)
+			}
+		})
+	}
+}