WIP: query log tests

0xERR0R · Nov 20, 2022 · 87e9200 · 87e9200
1 parent 9d3b3c1
commit 87e9200
Show file tree

Hide file tree

Showing 2 changed files with 243 additions and 1 deletion.
diff --git a/e2e/containers.go b/e2e/containers.go
@@ -21,7 +21,9 @@ var NetworkName = fmt.Sprintf("blocky-e2e-network_%d", time.Now().Unix())
 
 const (
 	redisImage        = "redis:7"
-	mokaImage         = "ghcr.io/0xerr0r/dns-mokka:latest"
+	postgresImage     = "postgres:15"
+	mariaDBImage      = "mariadb:10"
+	mokaImage         = "ghcr.io/0xerr0r/dns-mokka:0.2.0"
 	staticServerImage = "halverneus/static-file-server:latest"
 	blockyImage       = "blocky-e2e"
 )
@@ -103,6 +105,54 @@ func createRedisContainer() (testcontainers.Container, error) {
 	return container, err
 }
 
+func createPostgresContainer() (testcontainers.Container, error) {
+	ctx := context.Background()
+
+	req := testcontainers.ContainerRequest{
+		Image:          postgresImage,
+		Networks:       []string{NetworkName},
+		ExposedPorts:   []string{"5432/tcp"},
+		NetworkAliases: map[string][]string{NetworkName: {"postgres"}},
+		Env: map[string]string{
+			"POSTGRES_USER":     "user",
+			"POSTGRES_PASSWORD": "user",
+		},
+		WaitingFor: wait.ForExposedPort(),
+	}
+
+	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+
+	return container, err
+}
+
+func createMariaDBContainer() (testcontainers.Container, error) {
+	ctx := context.Background()
+
+	req := testcontainers.ContainerRequest{
+		Image:          mariaDBImage,
+		Networks:       []string{NetworkName},
+		ExposedPorts:   []string{"3306/tcp"},
+		NetworkAliases: map[string][]string{NetworkName: {"mariaDB"}},
+		Env: map[string]string{
+			"MARIADB_USER":          "user",
+			"MARIADB_PASSWORD":      "user",
+			"MARIADB_DATABASE":      "user",
+			"MARIADB_ROOT_PASSWORD": "user",
+		},
+		WaitingFor: wait.ForAll(wait.ForLog("ready for connections"), wait.ForExposedPort()),
+	}
+
+	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+
+	return container, err
+}
+
 func createBlockyContainer(tmpDir *helpertest.TmpFolder, lines ...string) (testcontainers.Container, error) {
 	f1 := tmpDir.CreateStringFile("config1.yaml",
 		lines...,

diff --git a/e2e/querylog_test.go b/e2e/querylog_test.go
@@ -0,0 +1,192 @@
+package e2e
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/0xERR0R/blocky/util"
+	"github.com/miekg/dns"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/testcontainers/testcontainers-go"
+	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+var _ = Describe("Query logs functional tests", func() {
+	var blocky, moka, database testcontainers.Container
+	var db *gorm.DB
+	var err error
+
+	BeforeEach(func() {
+		moka, err = createDNSMokkaContainer("moka1", `A google/NOERROR("A 1.2.3.4 123")`, `A unknown/NXDOMAIN()`)
+
+		Expect(err).Should(Succeed())
+		DeferCleanup(moka.Terminate)
+	})
+
+	FDescribe("Query logging into the mariaDB database", func() {
+		BeforeEach(func() {
+
+			database, err = createMariaDBContainer()
+			Expect(err).Should(Succeed())
+			DeferCleanup(database.Terminate)
+
+			blocky, err = createBlockyContainer(tmpDir,
+				"logLevel: warn",
+				"upstream:",
+				"  default:",
+				"    - moka1",
+				"queryLog:",
+				"  type: mysql",
+				"  target: user:user@tcp(mariaDB:3306)/user?charset=utf8mb4&parseTime=True&loc=Local",
+			)
+
+			Expect(err).Should(Succeed())
+			DeferCleanup(blocky.Terminate)
+
+			dbPort, err := getContainerPort(database, "3306/tcp")
+			Expect(err).Should(Succeed())
+
+			host, err := database.Host(context.Background())
+			Expect(err).Should(Succeed())
+
+			dsn := fmt.Sprintf("user:user@tcp(%s:%d)/user?charset=utf8mb4&parseTime=True&loc=Local", host, dbPort)
+			db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
+			Expect(err).Should(Succeed())
+
+			Eventually(countEntries).WithArguments(db).Should(BeNumerically("==", 0))
+
+		})
+		When("Some queries were performed", func() {
+			It("Should store query log in the mariaDB database", func() {
+				By("Performing 2 queries", func() {
+					Expect(doDNSRequest(blocky, util.NewMsgWithQuestion("google.de.", dns.Type(dns.TypeA)))).Should(Not(BeNil()))
+					Expect(doDNSRequest(blocky, util.NewMsgWithQuestion("unknown.domain.", dns.Type(dns.TypeA)))).Should(Not(BeNil()))
+				})
+
+				By("check entries count asynchronously, since blocky flushes log entries in bulk", func() {
+					Eventually(countEntries, "60s", "1s").WithArguments(db).Should(BeNumerically("==", 2))
+				})
+
+				By("check entry content", func() {
+					entries, err := queryEntries(db)
+					Expect(err).Should(Succeed())
+
+					Expect(entries).Should(HaveLen(2))
+
+					Expect(entries[0]).Should(SatisfyAll(
+						HaveField("ResponseType", "RESOLVED"),
+						HaveField("QuestionType", "A"),
+						HaveField("QuestionName", "google.de"),
+						HaveField("Answer", "A (1.2.3.4)"),
+						HaveField("ResponseCode", "NOERROR"),
+					))
+
+					Expect(entries[1]).Should(SatisfyAll(
+						HaveField("ResponseType", "RESOLVED"),
+						HaveField("QuestionType", "A"),
+						HaveField("QuestionName", "unknown.domain"),
+						HaveField("Answer", ""),
+						HaveField("ResponseCode", "NXDOMAIN"),
+					))
+				})
+
+				Expect(getContainerLogs(blocky)).Should(BeEmpty())
+			})
+
+		})
+	})
+
+	Describe("Query logging into the postgres database", func() {
+		BeforeEach(func() {
+
+			database, err = createPostgresContainer()
+			Expect(err).Should(Succeed())
+			DeferCleanup(database.Terminate)
+
+			blocky, err = createBlockyContainer(tmpDir,
+				"logLevel: warn",
+				"upstream:",
+				"  default:",
+				"    - moka1",
+				"queryLog:",
+				"  type: postgresql",
+				"  target: postgres://user:user@postgres:5432/user",
+			)
+
+			Expect(err).Should(Succeed())
+			DeferCleanup(blocky.Terminate)
+
+			dbPort, err := getContainerPort(database, "5432/tcp")
+			Expect(err).Should(Succeed())
+
+			dsn := fmt.Sprintf("postgres://user:user@localhost:%d/user", dbPort)
+			db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
+			Expect(err).Should(Succeed())
+
+			Eventually(countEntries).WithArguments(db).Should(BeNumerically("==", 0))
+
+		})
+		When("Some queries were performed", func() {
+			msg := util.NewMsgWithQuestion("google.de.", dns.Type(dns.TypeA))
+			It("Should store query log in the postgres database", func() {
+				By("Performing 2 queries", func() {
+					Expect(doDNSRequest(blocky, msg)).Should(Not(BeNil()))
+					Expect(doDNSRequest(blocky, msg)).Should(Not(BeNil()))
+				})
+
+				By("check entries count asynchronously, since blocky flushes log entries in bulk", func() {
+					Eventually(countEntries, "60s", "1s").WithArguments(db).Should(BeNumerically("==", 2))
+				})
+
+				By("check entry content", func() {
+					entries, err := queryEntries(db)
+					Expect(err).Should(Succeed())
+
+					Expect(entries).Should(HaveLen(2))
+
+					Expect(entries[0]).Should(SatisfyAll(
+						HaveField("ResponseType", "RESOLVED"),
+						HaveField("QuestionType", "A"),
+						HaveField("QuestionName", "google.de"),
+						HaveField("Answer", "A (1.2.3.4)"),
+						HaveField("ResponseCode", "NOERROR"),
+					))
+
+					Expect(entries[1]).Should(SatisfyAll(
+						HaveField("ResponseType", "CACHED"),
+						HaveField("QuestionType", "A"),
+						HaveField("QuestionName", "google.de"),
+						HaveField("Answer", "A (1.2.3.4)"),
+						HaveField("ResponseCode", "NOERROR"),
+					))
+				})
+
+				Expect(getContainerLogs(blocky)).Should(BeEmpty())
+			})
+
+		})
+	})
+})
+
+type logEntry struct {
+	ResponseType string
+	QuestionType string
+	QuestionName string
+	Answer       string
+	ResponseCode string
+}
+
+func queryEntries(db *gorm.DB) ([]logEntry, error) {
+	var entries []logEntry
+
+	return entries, db.Find(&entries).Order("request_ts DESC").Error
+}
+
+func countEntries(db *gorm.DB) (int64, error) {
+	var cnt int64
+
+	return cnt, db.Table("log_entries").Count(&cnt).Error
+}