mirrors
/
blocky
mirror of https://github.com/0xERR0R/blocky.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Replace all sleeps in tests with "eventually" from gomega (#379)

This commit is contained in:
Dimitri Herzog 2021-12-22 22:20:39 +01:00
parent 44e3adaa93
commit d7bf373b52
7 changed files with 218 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
lists/list_cache_test.go
View File

@ -85,11 +85,13 @@ var _ = Describe("ListCache", func() {
"gr1": {s.URL},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 100*time.Millisecond, 3, time.Second)
time.Sleep(time.Second)
found, group := sut.Match("blocked1.com", []string{"gr1"})
Expect(found).Should(BeTrue())
Expect(group).Should(Equal("gr1"))
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 100*time.Millisecond, 3, time.Millisecond)
Eventually(func(g Gomega) {
found, group := sut.Match("blocked1.com", []string{"gr1"})
g.Expect(found).Should(BeTrue())
g.Expect(group).Should(Equal("gr1"))
}, "1s").Should(Succeed())
})
})
When("a temporary err occurs on download", func() {
@ -111,12 +113,14 @@ var _ = Describe("ListCache", func() {
"gr1": {s.URL, emptyFile.Name()},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 4*time.Hour, 100*time.Millisecond, 3, time.Second)
time.Sleep(time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 4*time.Hour, 100*time.Millisecond, 3, time.Millisecond)
By("Lists loaded without timeout", func() {
found, group := sut.Match("blocked1.com", []string{"gr1"})
Expect(found).Should(BeTrue())
Expect(group).Should(Equal("gr1"))
Eventually(func(g Gomega) {
found, group := sut.Match("blocked1.com", []string{"gr1"})
g.Expect(found).Should(BeTrue())
g.Expect(group).Should(Equal("gr1"))
}, "1s").Should(Succeed())
})
sut.Refresh()
@ -147,20 +151,23 @@ var _ = Describe("ListCache", func() {
"gr1": {s.URL},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Second)
time.Sleep(time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Millisecond)
By("Lists loaded without err", func() {
found, group := sut.Match("blocked1.com", []string{"gr1"})
Expect(found).Should(BeTrue())
Expect(group).Should(Equal("gr1"))
Eventually(func(g Gomega) {
found, group := sut.Match("blocked1.com", []string{"gr1"})
g.Expect(found).Should(BeTrue())
g.Expect(group).Should(Equal("gr1"))
}, "1s").Should(Succeed())
})
sut.Refresh()
time.Sleep(time.Second)
By("List couldn't be loaded due to 404 err", func() {
found, _ := sut.Match("blocked1.com", []string{"gr1"})
Expect(found).Should(BeFalse())
Eventually(func() bool {
found, _ := sut.Match("blocked1.com", []string{"gr1"})
return found
}, "1s").Should(BeFalse())
})
})
})
@ -171,7 +178,7 @@ var _ = Describe("ListCache", func() {
"gr2": {server3.URL},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Millisecond)
found, group := sut.Match("blocked1.com", []string{"gr1", "gr2"})
Expect(found).Should(BeTrue())
@ -192,7 +199,7 @@ var _ = Describe("ListCache", func() {
"withDeadLink": {"http://wrong.host.name"},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Millisecond)
found, group := sut.Match("blocked1.com", []string{})
Expect(found).Should(BeFalse())
@ -211,7 +218,7 @@ var _ = Describe("ListCache", func() {
resultCnt = cnt
})
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 30*time.Second, 3, time.Millisecond)
found, group := sut.Match("blocked1.com", []string{})
Expect(found).Should(BeFalse())
@ -226,7 +233,7 @@ var _ = Describe("ListCache", func() {
"gr2": {"file://" + file3.Name()},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Millisecond)
found, group := sut.Match("blocked1.com", []string{"gr1", "gr2"})
Expect(found).Should(BeTrue())
@ -247,7 +254,7 @@ var _ = Describe("ListCache", func() {
"gr1": {"inlinedomain1.com\n#some comment\n#inlinedomain2.com"},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Millisecond)
found, group := sut.Match("inlinedomain1.com", []string{"gr1"})
Expect(found).Should(BeTrue())
@ -264,7 +271,7 @@ var _ = Describe("ListCache", func() {
"gr1": {"/^apple\\.(de|com)$/\n"},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Millisecond)
found, group := sut.Match("apple.com", []string{"gr1"})
Expect(found).Should(BeTrue())
@ -284,7 +291,7 @@ var _ = Describe("ListCache", func() {
"gr2": {"inline\ndefinition\n"},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, 0, 0, 3, time.Millisecond)
c := sut.Configuration()
Expect(c).Should(HaveLen(11))
@ -296,7 +303,7 @@ var _ = Describe("ListCache", func() {
"gr1": {"file1", "file2"},
}
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, -1, 0, 3, time.Second)
sut, _ := NewListCache(ListCacheTypeBlacklist, lists, -1, 0, 3, time.Millisecond)
c := sut.Configuration()
Expect(c).Should(ContainElement("refresh: disabled"))

41
querylog/database_writer_test.go
View File

@ -20,7 +20,7 @@ var _ = Describe("DatabaseWriter", func() {
When("New log entry was created", func() {
It("should be persisted in the database", func() {
sqlite := sqlite.Open("file::memory:")
writer, err := newDatabaseWriter(sqlite, 7, 1)
writer, err := newDatabaseWriter(sqlite, 7, time.Millisecond)
Expect(err).Should(Succeed())
request := &model.Request{
Req: util.NewMsgWithQuestion("google.de.", dns.TypeA),
@ -40,22 +40,19 @@ var _ = Describe("DatabaseWriter", func() {
Start: time.Now(),
DurationMs: 20,
})
time.Sleep(500 * time.Millisecond)
result := writer.db.Find(&logEntry{})
var cnt int64
result.Count(&cnt)
Expect(cnt).Should(Equal(int64(1)))
Eventually(func() (res int64) {
result := writer.db.Find(&logEntry{})
result.Count(&res)
return res
}, "1s").Should(BeNumerically("==", 1))
})
})
When("There are log entries with timestamp exceeding the retention period", func() {
It("these old entries should be deleted", func() {
sqlite := sqlite.Open("file::memory:")
writer, err := newDatabaseWriter(sqlite, 1, 1)
writer, err := newDatabaseWriter(sqlite, 1, time.Millisecond)
Expect(err).Should(Succeed())
request := &model.Request{
@ -87,23 +84,25 @@ var _ = Describe("DatabaseWriter", func() {
DurationMs: 20,
})
result := writer.db.Find(&logEntry{})
time.Sleep(500 * time.Millisecond)
var cnt int64
result.Count(&cnt)
// 2 entries in the database
Expect(cnt).Should(Equal(int64(2)))
Eventually(func() int64 {
var res int64
result := writer.db.Find(&logEntry{})
result.Count(&res)
return res
}, "1s").Should(BeNumerically("==", 2))
// do cleanup now
writer.CleanUp()
result.Count(&cnt)
// now only 1 entry in the database
Expect(cnt).Should(Equal(int64(1)))
Eventually(func() (res int64) {
result := writer.db.Find(&logEntry{})
result.Count(&res)
return res
}, "1s").Should(BeNumerically("==", 1))
})
})

22
redis/redis_test.go
View File

@ -1,8 +1,6 @@
package redis
import (
"time"
"github.com/0xERR0R/blocky/config"
"github.com/0xERR0R/blocky/util"
"github.com/alicebob/miniredis/v2"
@ -88,11 +86,9 @@ var _ = Describe("Redis client", func() {
Expect(err).Should(Succeed())
redisClient.PublishCache("example.com", res)
time.Sleep(50 * time.Millisecond)
keysLen := len(redisServer.DB(redisConfig.Database).Keys())
Expect(keysLen).To(Equal(1))
Eventually(func() []string {
return redisServer.DB(redisConfig.Database).Keys()
}, "100ms").Should(HaveLen(1))
})
})
When("GetRedisCache", func() {
@ -106,16 +102,16 @@ var _ = Describe("Redis client", func() {
redisClient.PublishCache("example.com", res)
time.Sleep(50 * time.Millisecond)
keysLen := len(redisServer.DB(redisConfig.Database).Keys())
Expect(keysLen).To(Equal(1))
Eventually(func() []string {
return redisServer.DB(redisConfig.Database).Keys()
}, "100ms").Should(HaveLen(1))
redisClient.GetRedisCache()
time.Sleep(50 * time.Millisecond)
Eventually(func() []string {
return redisServer.DB(redisConfig.Database).Keys()
}, "100ms").Should(HaveLen(origCount + 1))
Expect(len(redisClient.CacheChannel)).To(Equal(origCount + 1))
})
})
})

15
resolver/blocking_resolver_test.go
View File

@ -99,10 +99,7 @@ badcnamedomain.com`)
tmp, _ := NewBlockingResolver(sutConfig)
sut = tmp.(*BlockingResolver)
time.Sleep(time.Second)
Expect(groupCnt).Should(HaveLen(2))
Eventually(groupCnt, "1s").Should(HaveLen(2))
})
})
})
@ -666,8 +663,9 @@ badcnamedomain.com`)
enabled = state
})
// wait 1 sec
time.Sleep(time.Second)
Expect(enabled).Should(BeTrue())
Eventually(func() bool {
return enabled
}, "1s").Should(BeTrue())
resp, err := sut.Resolve(newRequestWithClient("blocked3.com.", dns.TypeA, "1.2.1.2", "unknown"))
Expect(err).Should(Succeed())
@ -727,8 +725,9 @@ badcnamedomain.com`)
enabled = state
})
// wait 1 sec
time.Sleep(time.Second)
Expect(enabled).Should(BeTrue())
Eventually(func() bool {
return enabled
}, "1s").Should(BeTrue())
resp, err := sut.Resolve(newRequestWithClient("blocked3.com.", dns.TypeA, "1.2.1.2", "unknown"))
Expect(err).Should(Succeed())

191
resolver/caching_resolver_test.go
View File

@ -95,14 +95,15 @@ var _ = Describe("CachingResolver", func() {
_, _ = sut.Resolve(newRequest("example.com.", dns.TypeA))
}
time.Sleep(50 * time.Millisecond)
Eventually(func(g Gomega) {
// now is this domain prefetched
g.Expect(domainPrefetched).Should(Equal("example.com"))
// now is this domain prefetched
Expect(domainPrefetched).Should(Equal("example.com"))
// and it should hit from prefetch cache
_, _ = sut.Resolve(newRequest("example.com.", dns.TypeA))
g.Expect(prefetchHitDomain).Should(Equal("example.com"))
}, "50ms").Should(Succeed())
// and it should hit from prefetch cache
_, _ = sut.Resolve(newRequest("example.com.", dns.TypeA))
Expect(prefetchHitDomain).Should(Equal("example.com"))
})
})
When("min caching time is defined", func() {
@ -140,24 +141,25 @@ var _ = Describe("CachingResolver", func() {
Expect(totalCacheCount).Should(Equal(1))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
domain := ""
_ = Bus().SubscribeOnce(CachingResultCacheHit, func(d string) {
domain = d
})
Eventually(func(g Gomega) {
domain := ""
_ = Bus().SubscribeOnce(CachingResultCacheHit, func(d string) {
domain = d
})
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
// still one call to upstream
Expect(m.Calls).Should(HaveLen(1))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// ttl is smaller
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.", dns.TypeA, 599, "123.122.121.120"))
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
// still one call to upstream
g.Expect(m.Calls).Should(HaveLen(1))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// ttl is smaller
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.", dns.TypeA, 599, "123.122.121.120"))
g.Expect(domain).Should(Equal("example.com"))
}, "500ms").Should(Succeed())
Expect(domain).Should(Equal("example.com"))
})
})
})
@ -178,17 +180,17 @@ var _ = Describe("CachingResolver", func() {
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.", dns.TypeA, 300, "123.122.121.120"))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.", dns.TypeA, 299, "123.122.121.120"))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
g.Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.", dns.TypeA, 299, "123.122.121.120"))
}, "500ms").Should(Succeed())
})
})
})
@ -211,18 +213,19 @@ var _ = Describe("CachingResolver", func() {
dns.TypeAAAA, 300, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 299, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
g.Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 299, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
}, "500ms").Should(Succeed())
})
})
})
@ -253,17 +256,17 @@ var _ = Describe("CachingResolver", func() {
dns.TypeAAAA, 1230, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeRESOLVED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// one more call to upstream
Expect(m.Calls).Should(HaveLen(2))
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 1230, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeRESOLVED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// one more call to upstream
g.Expect(m.Calls).Should(HaveLen(2))
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 1230, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
}, "500ms").Should(Succeed())
})
})
})
@ -285,18 +288,18 @@ var _ = Describe("CachingResolver", func() {
dns.TypeAAAA, 240, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 239, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
g.Expect(m.Calls).Should(HaveLen(1))
// ttl is smaller
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeAAAA, 239, "2001:db8:85a3:8d3:1319:8a2e:370:7344"))
}, "500ms").Should(Succeed())
})
})
})
@ -322,18 +325,19 @@ var _ = Describe("CachingResolver", func() {
dns.TypeA, 1, "1.1.1.1"))
})
time.Sleep(1100 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
Expect(m.Calls).Should(HaveLen(1))
// ttl is 0
Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeA, 0, "1.1.1.1"))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess))
// still one call to upstream
g.Expect(m.Calls).Should(HaveLen(1))
// ttl is 0
g.Expect(resp.Res.Answer).Should(BeDNSRecord("example.com.",
dns.TypeA, 0, "1.1.1.1"))
}, "1100ms").Should(Succeed())
})
})
})
@ -355,16 +359,16 @@ var _ = Describe("CachingResolver", func() {
Expect(m.Calls).Should(HaveLen(1))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
Expect(resp.Reason).Should(Equal("CACHED NEGATIVE"))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeNameError))
// still one call to resolver
Expect(m.Calls).Should(HaveLen(1))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeCACHED))
g.Expect(resp.Reason).Should(Equal("CACHED NEGATIVE"))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeNameError))
// still one call to resolver
g.Expect(m.Calls).Should(HaveLen(1))
}, "500ms").Should(Succeed())
})
})
@ -386,14 +390,14 @@ var _ = Describe("CachingResolver", func() {
Expect(m.Calls).Should(HaveLen(1))
})
time.Sleep(500 * time.Millisecond)
By("second request", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
Expect(err).Should(Succeed())
Expect(resp.RType).Should(Equal(ResponseTypeRESOLVED))
Expect(resp.Res.Rcode).Should(Equal(dns.RcodeNameError))
Expect(m.Calls).Should(HaveLen(2))
Eventually(func(g Gomega) {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeAAAA))
g.Expect(err).Should(Succeed())
g.Expect(resp.RType).Should(Equal(ResponseTypeRESOLVED))
g.Expect(resp.Res.Rcode).Should(Equal(dns.RcodeNameError))
g.Expect(m.Calls).Should(HaveLen(2))
}, "500ms").Should(Succeed())
})
})
@ -501,10 +505,9 @@ var _ = Describe("CachingResolver", func() {
resp, err = sut.Resolve(newRequest("example.com.", dns.TypeA))
Expect(err).Should(Succeed())
time.Sleep(50 * time.Millisecond)
keysLen := len(redisServer.DB(redisConfig.Database).Keys())
Expect(keysLen).To(Equal(1))
Eventually(func() []string {
return redisServer.DB(redisConfig.Database).Keys()
}, "50ms").Should(HaveLen(1))
})
})
})

81
resolver/query_logging_resolver_test.go
View File

@ -14,7 +14,6 @@ import (
"github.com/0xERR0R/blocky/querylog"
"github.com/0xERR0R/blocky/config"
. "github.com/0xERR0R/blocky/log"
. "github.com/0xERR0R/blocky/model"
"github.com/0xERR0R/blocky/util"
@ -101,29 +100,36 @@ var _ = Describe("QueryLoggingResolver", func() {
Expect(err).Should(Succeed())
})
time.Sleep(100 * time.Millisecond)
m.AssertExpectations(GinkgoT())
By("check log for client1", func() {
csvLines := readCsv(filepath.Join(tmpDir, fmt.Sprintf("%s_client1.log", time.Now().Format("2006-01-02"))))
Eventually(func(g Gomega) {
csvLines, err := readCsv(filepath.Join(tmpDir, fmt.Sprintf("%s_client1.log", time.Now().Format("2006-01-02"))))
g.Expect(err).Should(Succeed())
g.Expect(csvLines).Should(Not(BeEmpty()))
g.Expect(csvLines[0][1]).Should(Equal("192.168.178.25"))
g.Expect(csvLines[0][2]).Should(Equal("client1"))
g.Expect(csvLines[0][4]).Should(Equal("reason"))
g.Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
g.Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
}, "1s").Should(Succeed())
Expect(csvLines).Should(HaveLen(1))
Expect(csvLines[0][1]).Should(Equal("192.168.178.25"))
Expect(csvLines[0][2]).Should(Equal("client1"))
Expect(csvLines[0][4]).Should(Equal("reason"))
Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
})
By("check log for client2", func() {
csvLines := readCsv(filepath.Join(tmpDir, fmt.Sprintf("%s_cl_ient2_test.log", time.Now().Format("2006-01-02"))))
Eventually(func(g Gomega) {
csvLines, err := readCsv(filepath.Join(tmpDir,
fmt.Sprintf("%s_cl_ient2_test.log", time.Now().Format("2006-01-02"))))
Expect(csvLines).Should(HaveLen(1))
Expect(csvLines[0][1]).Should(Equal("192.168.178.26"))
Expect(csvLines[0][2]).Should(Equal("cl/ient2\\$%&test"))
Expect(csvLines[0][4]).Should(Equal("reason"))
Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
g.Expect(err).Should(Succeed())
g.Expect(csvLines).Should(HaveLen(1))
g.Expect(csvLines[0][1]).Should(Equal("192.168.178.26"))
g.Expect(csvLines[0][2]).Should(Equal("cl/ient2\\$%&test"))
g.Expect(csvLines[0][4]).Should(Equal("reason"))
g.Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
g.Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
}, "1s").Should(Succeed())
})
})
})
@ -147,26 +153,29 @@ var _ = Describe("QueryLoggingResolver", func() {
Expect(err).Should(Succeed())
})
time.Sleep(100 * time.Millisecond)
m.AssertExpectations(GinkgoT())
By("check log", func() {
csvLines := readCsv(filepath.Join(tmpDir, fmt.Sprintf("%s_ALL.log", time.Now().Format("2006-01-02"))))
Eventually(func(g Gomega) {
csvLines, err := readCsv(filepath.Join(tmpDir, fmt.Sprintf("%s_ALL.log", time.Now().Format("2006-01-02"))))
Expect(csvLines).Should(HaveLen(2))
// client1 -> first line
Expect(csvLines[0][1]).Should(Equal("192.168.178.25"))
Expect(csvLines[0][2]).Should(Equal("client1"))
Expect(csvLines[0][4]).Should(Equal("reason"))
Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
g.Expect(err).Should(Succeed())
g.Expect(csvLines).Should(HaveLen(2))
// client1 -> first line
g.Expect(csvLines[0][1]).Should(Equal("192.168.178.25"))
g.Expect(csvLines[0][2]).Should(Equal("client1"))
g.Expect(csvLines[0][4]).Should(Equal("reason"))
g.Expect(csvLines[0][5]).Should(Equal("A (example.com.)"))
g.Expect(csvLines[0][6]).Should(Equal("A (123.122.121.120)"))
// client2 -> second line
g.Expect(csvLines[1][1]).Should(Equal("192.168.178.26"))
g.Expect(csvLines[1][2]).Should(Equal("client2"))
g.Expect(csvLines[1][4]).Should(Equal("reason"))
g.Expect(csvLines[1][5]).Should(Equal("A (example.com.)"))
g.Expect(csvLines[1][6]).Should(Equal("A (123.122.121.120)"))
}, "1s").Should(Succeed())
// client2 -> second line
Expect(csvLines[1][1]).Should(Equal("192.168.178.26"))
Expect(csvLines[1][2]).Should(Equal("client2"))
Expect(csvLines[1][4]).Should(Equal("reason"))
Expect(csvLines[1][5]).Should(Equal("A (example.com.)"))
Expect(csvLines[1][6]).Should(Equal("A (123.122.121.120)"))
})
})
})
@ -284,11 +293,13 @@ var _ = Describe("Wrong target configuration", func() {
})
})
func readCsv(file string) [][]string {
func readCsv(file string) ([][]string, error) {
var result [][]string
csvFile, err := os.Open(file)
Expect(err).Should(Succeed())
if err != nil {
return nil, err
}
reader := csv.NewReader(bufio.NewReader(csvFile))
reader.Comma = '\t'
@ -298,11 +309,11 @@ func readCsv(file string) [][]string {
if errors.Is(err, io.EOF) {
break
} else if err != nil {
Log().Fatal("can't read line", err)
return nil, err
}
result = append(result, line)
}
return result
return result, nil
}

10
server/server_test.go
View File

@ -558,16 +558,18 @@ var _ = Describe("Running DNS server", func() {
defer server.Stop()
time.Sleep(100 * time.Millisecond)
Eventually(func() bool {
return fatal
}, "100ms").Should(BeFalse())
Expect(fatal).Should(BeFalse())
// start again -> should fail
server.Start()
time.Sleep(100 * time.Millisecond)
Expect(fatal).Should(BeTrue())
Eventually(func() bool {
return fatal
}, "100ms").Should(BeTrue())
})
})
})