From d501d867dfecbabd906d903e476ecfbd23295f6d Mon Sep 17 00:00:00 2001 From: ThinkChaos Date: Thu, 1 Dec 2022 20:42:17 -0500 Subject: [PATCH] style(resolver): standardize configuration disabled impls and tests --- lists/list_cache_test.go | 2 +- resolver/blocking_resolver.go | 44 +++++++++---------- resolver/blocking_resolver_test.go | 3 +- resolver/caching_resolver.go | 4 +- resolver/caching_resolver_test.go | 3 +- resolver/client_names_resolver.go | 26 +++++------ resolver/client_names_resolver_test.go | 5 +-- resolver/conditional_upstream_resolver.go | 12 ++--- .../conditional_upstream_resolver_test.go | 3 +- resolver/custom_dns_resolver.go | 12 ++--- resolver/custom_dns_resolver_test.go | 5 +-- resolver/ede_resolver.go | 10 ++--- resolver/ede_resolver_test.go | 41 +++++++++++------ resolver/filtering_resolver.go | 10 +++-- resolver/filtering_resolver_test.go | 6 +-- resolver/fqdn_only_resolver.go | 8 ++-- resolver/fqdn_only_resolver_test.go | 14 +++--- resolver/hosts_file_resolver.go | 14 +++--- resolver/hosts_file_resolver_test.go | 5 +-- resolver/metrics_resolver.go | 4 ++ resolver/resolver.go | 15 +++++++ resolver/sudn_resolver.go | 2 +- resolver/sudn_resolver_test.go | 4 +- resolver/upstream_resolver.go | 2 +- resolver/upstream_resolver_test.go | 4 +- 25 files changed, 139 insertions(+), 119 deletions(-) diff --git a/lists/list_cache_test.go b/lists/list_cache_test.go index 4d82bc1dc..25ffd10ac 100644 --- a/lists/list_cache_test.go +++ b/lists/list_cache_test.go @@ -349,7 +349,7 @@ var _ = Describe("ListCache", func() { c := sut.Configuration() Expect(c).Should(ContainElement("refresh period: 1 hour")) - Expect(c).Should(HaveLen(11)) + Expect(len(c)).Should(BeNumerically(">", 1)) }) }) When("refresh is disabled", func() { diff --git a/resolver/blocking_resolver.go b/resolver/blocking_resolver.go index 08566d229..791335b55 100644 --- a/resolver/blocking_resolver.go +++ b/resolver/blocking_resolver.go @@ -329,34 +329,34 @@ func (r *BlockingResolver) handleBlocked(logger *logrus.Entry, // Configuration returns the current resolver configuration func (r *BlockingResolver) Configuration() (result []string) { - if len(r.cfg.ClientGroupsBlock) > 0 { - result = append(result, "clientGroupsBlock") - for key, val := range r.cfg.ClientGroupsBlock { - result = append(result, fmt.Sprintf(" %s = \"%s\"", key, strings.Join(val, ";"))) - } + if len(r.cfg.ClientGroupsBlock) == 0 { + return configDisabled + } - blockType := r.cfg.BlockType - result = append(result, fmt.Sprintf("blockType = \"%s\"", blockType)) + result = append(result, "clientGroupsBlock") + for key, val := range r.cfg.ClientGroupsBlock { + result = append(result, fmt.Sprintf(" %s = \"%s\"", key, strings.Join(val, ";"))) + } - if blockType != "NXDOMAIN" { - result = append(result, fmt.Sprintf("blockTTL = %s", r.cfg.BlockTTL.String())) - } + blockType := r.cfg.BlockType + result = append(result, fmt.Sprintf("blockType = \"%s\"", blockType)) + + if blockType != "NXDOMAIN" { + result = append(result, fmt.Sprintf("blockTTL = %s", r.cfg.BlockTTL.String())) + } - result = append(result, fmt.Sprintf("downloadTimeout = %s", r.cfg.DownloadTimeout.String())) + result = append(result, fmt.Sprintf("downloadTimeout = %s", r.cfg.DownloadTimeout.String())) - result = append(result, fmt.Sprintf("FailStartOnListError = %t", r.cfg.FailStartOnListError)) + result = append(result, fmt.Sprintf("FailStartOnListError = %t", r.cfg.FailStartOnListError)) - result = append(result, "blacklist:") - for _, c := range r.blacklistMatcher.Configuration() { - result = append(result, fmt.Sprintf(" %s", c)) - } + result = append(result, "blacklist:") + for _, c := range r.blacklistMatcher.Configuration() { + result = append(result, fmt.Sprintf(" %s", c)) + } - result = append(result, "whitelist:") - for _, c := range r.whitelistMatcher.Configuration() { - result = append(result, fmt.Sprintf(" %s", c)) - } - } else { - result = []string{"deactivated"} + result = append(result, "whitelist:") + for _, c := range r.whitelistMatcher.Configuration() { + result = append(result, fmt.Sprintf(" %s", c)) } return result diff --git a/resolver/blocking_resolver_test.go b/resolver/blocking_resolver_test.go index 51d5a074d..9e29619b8 100644 --- a/resolver/blocking_resolver_test.go +++ b/resolver/blocking_resolver_test.go @@ -844,8 +844,7 @@ var _ = Describe("BlockingResolver", Label("blockingResolver"), func() { }) It("should return 'disabled''", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) diff --git a/resolver/caching_resolver.go b/resolver/caching_resolver.go index 5d81a2f9a..a5028095f 100644 --- a/resolver/caching_resolver.go +++ b/resolver/caching_resolver.go @@ -125,9 +125,7 @@ func (r *CachingResolver) onExpired(cacheKey string) (val interface{}, ttl time. // Configuration returns a current resolver configuration func (r *CachingResolver) Configuration() (result []string) { if r.maxCacheTimeSec < 0 { - result = []string{"deactivated"} - - return + return configDisabled } result = append(result, fmt.Sprintf("minCacheTimeInSec = %d", r.minCacheTimeSec)) diff --git a/resolver/caching_resolver_test.go b/resolver/caching_resolver_test.go index 33a9c1a49..66ee8acef 100644 --- a/resolver/caching_resolver_test.go +++ b/resolver/caching_resolver_test.go @@ -495,8 +495,7 @@ var _ = Describe("CachingResolver", func() { }) It("should return 'disabled'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) diff --git a/resolver/client_names_resolver.go b/resolver/client_names_resolver.go index b4eed0aa7..eb7c25076 100644 --- a/resolver/client_names_resolver.go +++ b/resolver/client_names_resolver.go @@ -48,24 +48,24 @@ func NewClientNamesResolver( // Configuration returns current resolver configuration func (r *ClientNamesResolver) Configuration() (result []string) { - if r.externalResolver != nil || len(r.clientIPMapping) > 0 { - result = append(result, fmt.Sprintf("singleNameOrder = \"%v\"", r.singleNameOrder)) + if r.externalResolver == nil && len(r.clientIPMapping) == 0 { + return append(configDisabled, "use only IP address") + } - if r.externalResolver != nil { - result = append(result, fmt.Sprintf("externalResolver = \"%s\"", r.externalResolver)) - } + result = append(result, fmt.Sprintf("singleNameOrder = \"%v\"", r.singleNameOrder)) + + if r.externalResolver != nil { + result = append(result, fmt.Sprintf("externalResolver = \"%s\"", r.externalResolver)) + } - result = append(result, fmt.Sprintf("cache item count = %d", r.cache.TotalCount())) + result = append(result, fmt.Sprintf("cache item count = %d", r.cache.TotalCount())) - if len(r.clientIPMapping) > 0 { - result = append(result, "client IP mapping:") + if len(r.clientIPMapping) > 0 { + result = append(result, "client IP mapping:") - for k, v := range r.clientIPMapping { - result = append(result, fmt.Sprintf("%s -> %s", k, v)) - } + for k, v := range r.clientIPMapping { + result = append(result, fmt.Sprintf("%s -> %s", k, v)) } - } else { - result = []string{"deactivated, use only IP address"} } return diff --git a/resolver/client_names_resolver_test.go b/resolver/client_names_resolver_test.go index 3c682c7bd..48e4e94c4 100644 --- a/resolver/client_names_resolver_test.go +++ b/resolver/client_names_resolver_test.go @@ -344,10 +344,9 @@ var _ = Describe("ClientResolver", Label("clientNamesResolver"), func() { BeforeEach(func() { sutConfig = config.ClientLookupConfig{} }) - It("should return 'deactivated'", func() { + It("should return 'disabled'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated, use only IP address"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) diff --git a/resolver/conditional_upstream_resolver.go b/resolver/conditional_upstream_resolver.go index 42401c5c9..96cae834f 100644 --- a/resolver/conditional_upstream_resolver.go +++ b/resolver/conditional_upstream_resolver.go @@ -41,12 +41,12 @@ func NewConditionalUpstreamResolver( // Configuration returns current configuration func (r *ConditionalUpstreamResolver) Configuration() (result []string) { - if len(r.mapping) > 0 { - for key, val := range r.mapping { - result = append(result, fmt.Sprintf("%s = \"%s\"", key, val)) - } - } else { - result = []string{"deactivated"} + if len(r.mapping) == 0 { + return configDisabled + } + + for key, val := range r.mapping { + result = append(result, fmt.Sprintf("%s = \"%s\"", key, val)) } return diff --git a/resolver/conditional_upstream_resolver_test.go b/resolver/conditional_upstream_resolver_test.go index 68df3e395..ab08ed6d2 100644 --- a/resolver/conditional_upstream_resolver_test.go +++ b/resolver/conditional_upstream_resolver_test.go @@ -145,8 +145,7 @@ var _ = Describe("ConditionalUpstreamResolver", Label("conditionalResolver"), fu }) It("should return 'disabled'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) }) diff --git a/resolver/custom_dns_resolver.go b/resolver/custom_dns_resolver.go index c449bf44a..7feb26e23 100644 --- a/resolver/custom_dns_resolver.go +++ b/resolver/custom_dns_resolver.go @@ -49,12 +49,12 @@ func NewCustomDNSResolver(cfg config.CustomDNSConfig) ChainedResolver { // Configuration returns current resolver configuration func (r *CustomDNSResolver) Configuration() (result []string) { - if len(r.mapping) > 0 { - for key, val := range r.mapping { - result = append(result, fmt.Sprintf("%s = \"%s\"", key, val)) - } - } else { - result = []string{"deactivated"} + if len(r.mapping) == 0 { + return configDisabled + } + + for key, val := range r.mapping { + result = append(result, fmt.Sprintf("%s = \"%s\"", key, val)) } return diff --git a/resolver/custom_dns_resolver_test.go b/resolver/custom_dns_resolver_test.go index ddcbc3664..00fa04ec1 100644 --- a/resolver/custom_dns_resolver_test.go +++ b/resolver/custom_dns_resolver_test.go @@ -196,7 +196,7 @@ var _ = Describe("CustomDNSResolver", func() { When("resolver is enabled", func() { It("should return configuration", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(3)) + Expect(len(c)).Should(BeNumerically(">", 1)) }) }) @@ -206,8 +206,7 @@ var _ = Describe("CustomDNSResolver", func() { }) It("should return 'disabled'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) }) diff --git a/resolver/ede_resolver.go b/resolver/ede_resolver.go index 748b9a5d6..a5ee47972 100644 --- a/resolver/ede_resolver.go +++ b/resolver/ede_resolver.go @@ -27,17 +27,15 @@ func (r *EdeResolver) Resolve(request *model.Request) (*model.Response, error) { addExtraReasoning(resp) } - return resp, err + return resp, nil } func (r *EdeResolver) Configuration() (result []string) { - if r.config.Enable { - result = []string{"activated"} - } else { - result = []string{"deactivated"} + if !r.config.Enable { + return configDisabled } - return result + return configEnabled } func addExtraReasoning(res *model.Response) { diff --git a/resolver/ede_resolver_test.go b/resolver/ede_resolver_test.go index 397927105..b54674cc2 100644 --- a/resolver/ede_resolver_test.go +++ b/resolver/ede_resolver_test.go @@ -38,13 +38,13 @@ var _ = Describe("EdeResolver", func() { sut.Next(m) }) - When("Ede is disabled", func() { + When("ede is disabled", func() { BeforeEach(func() { sutConfig = config.EdeConfig{ Enable: false, } }) - It("Shouldn't add EDE information", func() { + It("shouldn't add EDE information", func() { resp, err := sut.Resolve(newRequest("example.com", dns.Type(dns.TypeA))) Expect(err).Should(Succeed()) Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess)) @@ -55,19 +55,15 @@ var _ = Describe("EdeResolver", func() { // delegated to next resolver Expect(m.Calls).Should(HaveLen(1)) }) - It("Configure should output deactivated", func() { - c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("deactivated")) - }) }) - When("Ede is enabled", func() { + + When("ede is enabled", func() { BeforeEach(func() { sutConfig = config.EdeConfig{ Enable: true, } }) - It("Should add EDE information", func() { + It("should add EDE information", func() { resp, err := sut.Resolve(newRequest("example.com", dns.Type(dns.TypeA))) Expect(err).Should(Succeed()) Expect(resp.Res.Rcode).Should(Equal(dns.RcodeSuccess)) @@ -82,11 +78,6 @@ var _ = Describe("EdeResolver", func() { Expect(ede.InfoCode).Should(Equal(dns.ExtendedErrorCodeForgedAnswer)) Expect(ede.ExtraText).Should(Equal("Test")) }) - It("Configure should output activated", func() { - c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("activated")) - }) When("resolver returns an error", func() { resolveErr := errors.New("test") @@ -103,4 +94,26 @@ var _ = Describe("EdeResolver", func() { }) }) }) + + Describe("Configuration output", func() { + When("resolver is enabled", func() { + BeforeEach(func() { + sutConfig = config.EdeConfig{Enable: true} + }) + It("should return configuration", func() { + c := sut.Configuration() + Expect(c).Should(Equal(configEnabled)) + }) + }) + + When("resolver is disabled", func() { + BeforeEach(func() { + sutConfig = config.EdeConfig{Enable: false} + }) + It("should return 'disabled'", func() { + c := sut.Configuration() + Expect(c).Should(ContainElement(configStatusDisabled)) + }) + }) + }) }) diff --git a/resolver/filtering_resolver.go b/resolver/filtering_resolver.go index 09a42fafb..57ebf4d20 100644 --- a/resolver/filtering_resolver.go +++ b/resolver/filtering_resolver.go @@ -30,12 +30,14 @@ func (r *FilteringResolver) Resolve(request *model.Request) (*model.Response, er } func (r *FilteringResolver) Configuration() (result []string) { - qTypes := make([]string, len(r.queryTypes)) - ix := 0 + if len(r.queryTypes) == 0 { + return configDisabled + } + + qTypes := make([]string, 0, len(r.queryTypes)) for qType := range r.queryTypes { - qTypes[ix] = qType.String() - ix++ + qTypes = append(qTypes, qType.String()) } sort.Strings(qTypes) diff --git a/resolver/filtering_resolver_test.go b/resolver/filtering_resolver_test.go index 29a7c49dc..e52adc3f2 100644 --- a/resolver/filtering_resolver_test.go +++ b/resolver/filtering_resolver_test.go @@ -56,8 +56,7 @@ var _ = Describe("FilteringResolver", func() { }) It("Configure should output all query types", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("filtering query Types: 'AAAA, MX'")) + Expect(c).Should(Equal([]string{"filtering query Types: 'AAAA, MX'"})) }) }) @@ -74,8 +73,7 @@ var _ = Describe("FilteringResolver", func() { }) It("Configure should output 'empty list'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("filtering query Types: ''")) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) }) diff --git a/resolver/fqdn_only_resolver.go b/resolver/fqdn_only_resolver.go index 040ea6c23..9fb548bc0 100644 --- a/resolver/fqdn_only_resolver.go +++ b/resolver/fqdn_only_resolver.go @@ -35,11 +35,9 @@ func (r *FqdnOnlyResolver) Resolve(request *model.Request) (*model.Response, err } func (r *FqdnOnlyResolver) Configuration() (result []string) { - if r.enabled { - result = []string{"activated"} - } else { - result = []string{"deactivated"} + if !r.enabled { + return configDisabled } - return result + return configEnabled } diff --git a/resolver/fqdn_only_resolver_test.go b/resolver/fqdn_only_resolver_test.go index 028b7146a..eabd39a03 100644 --- a/resolver/fqdn_only_resolver_test.go +++ b/resolver/fqdn_only_resolver_test.go @@ -29,7 +29,7 @@ var _ = Describe("FqdnOnlyResolver", func() { sut.Next(m) }) - When("Fqdn only is activated", func() { + When("Fqdn only is enabled", func() { BeforeEach(func() { sutConfig = config.Config{ FqdnOnly: true, @@ -55,14 +55,13 @@ var _ = Describe("FqdnOnlyResolver", func() { // no call of next resolver Expect(m.Calls).Should(BeZero()) }) - It("Configure should output activated", func() { + It("Configure should output enabled", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("activated")) + Expect(c).Should(Equal(configEnabled)) }) }) - When("Fqdn only is deactivated", func() { + When("Fqdn only is disabled", func() { BeforeEach(func() { sutConfig = config.Config{ FqdnOnly: false, @@ -88,10 +87,9 @@ var _ = Describe("FqdnOnlyResolver", func() { // delegated to next resolver Expect(m.Calls).Should(HaveLen(1)) }) - It("Configure should output deactivated", func() { + It("Configure should output disabled", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c[0]).Should(Equal("deactivated")) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) }) diff --git a/resolver/hosts_file_resolver.go b/resolver/hosts_file_resolver.go index 0c5571f6c..da59e989b 100644 --- a/resolver/hosts_file_resolver.go +++ b/resolver/hosts_file_resolver.go @@ -122,15 +122,15 @@ func (r *HostsFileResolver) processHostEntry(host host, domain string, question } func (r *HostsFileResolver) Configuration() (result []string) { - if r.HostsFilePath != "" && len(r.hosts) != 0 { - result = append(result, fmt.Sprintf("hosts file path: %s", r.HostsFilePath)) - result = append(result, fmt.Sprintf("hosts TTL: %d", r.ttl)) - result = append(result, fmt.Sprintf("hosts refresh period: %s", r.refreshPeriod.String())) - result = append(result, fmt.Sprintf("filter loopback addresses: %t", r.filterLoopback)) - } else { - result = []string{"deactivated"} + if r.HostsFilePath == "" || len(r.hosts) == 0 { + return configDisabled } + result = append(result, fmt.Sprintf("file path: %s", r.HostsFilePath)) + result = append(result, fmt.Sprintf("TTL: %d", r.ttl)) + result = append(result, fmt.Sprintf("refresh period: %s", r.refreshPeriod.String())) + result = append(result, fmt.Sprintf("filter loopback addresses: %t", r.filterLoopback)) + return } diff --git a/resolver/hosts_file_resolver_test.go b/resolver/hosts_file_resolver_test.go index 2d4c51ee8..39ce2949a 100644 --- a/resolver/hosts_file_resolver_test.go +++ b/resolver/hosts_file_resolver_test.go @@ -174,7 +174,7 @@ var _ = Describe("HostsFileResolver", func() { When("hosts file is provided", func() { It("should return configuration", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(4)) + Expect(len(c)).Should(BeNumerically(">", 1)) }) }) @@ -184,8 +184,7 @@ var _ = Describe("HostsFileResolver", func() { }) It("should return 'disabled'", func() { c := sut.Configuration() - Expect(c).Should(HaveLen(1)) - Expect(c).Should(Equal([]string{"deactivated"})) + Expect(c).Should(ContainElement(configStatusDisabled)) }) }) }) diff --git a/resolver/metrics_resolver.go b/resolver/metrics_resolver.go index 7a476a858..836394e62 100644 --- a/resolver/metrics_resolver.go +++ b/resolver/metrics_resolver.go @@ -56,6 +56,10 @@ func (m *MetricsResolver) Resolve(request *model.Request) (*model.Response, erro // Configuration gets the config of this resolver in a string slice func (m *MetricsResolver) Configuration() (result []string) { + if !m.cfg.Enable { + return configDisabled + } + result = append(result, "metrics:") result = append(result, fmt.Sprintf(" Enable = %t", m.cfg.Enable)) result = append(result, fmt.Sprintf(" Path = %s", m.cfg.Path)) diff --git a/resolver/resolver.go b/resolver/resolver.go index 5848cbb81..42ed7b283 100644 --- a/resolver/resolver.go +++ b/resolver/resolver.go @@ -1,3 +1,4 @@ +//go:generate go run github.com/abice/go-enum -f=$GOFILE --marshal --names package resolver import ( @@ -14,6 +15,20 @@ import ( "github.com/sirupsen/logrus" ) +// Resolver is not configured. +const ( + configStatusEnabled string = "enabled" + + configStatusDisabled string = "disabled" +) + +var ( + // note: this is not used by all resolvers: only those that don't print any other configuration + configEnabled = []string{configStatusEnabled} //nolint:gochecknoglobals + + configDisabled = []string{configStatusDisabled} //nolint:gochecknoglobals +) + func newRequest(question string, rType dns.Type, logger ...*logrus.Entry) *model.Request { var loggerEntry *logrus.Entry if len(logger) == 1 { diff --git a/resolver/sudn_resolver.go b/resolver/sudn_resolver.go index 4ca480246..cc0ddfa20 100644 --- a/resolver/sudn_resolver.go +++ b/resolver/sudn_resolver.go @@ -80,7 +80,7 @@ func (r *SpecialUseDomainNamesResolver) Resolve(request *model.Request) (*model. // RFC 6761 & 6762 are always active func (r *SpecialUseDomainNamesResolver) Configuration() []string { - return []string{} + return configEnabled } func (r *SpecialUseDomainNamesResolver) isSpecial(request *model.Request, names ...string) bool { diff --git a/resolver/sudn_resolver_test.go b/resolver/sudn_resolver_test.go index 3ea6381a3..3f00a8a6a 100644 --- a/resolver/sudn_resolver_test.go +++ b/resolver/sudn_resolver_test.go @@ -99,7 +99,9 @@ var _ = Describe("SudnResolver", Label("sudnResolver"), func() { Describe("Configuration pseudo test", func() { It("should always be empty", func() { - Expect(sut.Configuration()).Should(HaveLen(0)) + c := sut.Configuration() + + Expect(len(c)).Should(BeNumerically(">=", 1)) }) }) }) diff --git a/resolver/upstream_resolver.go b/resolver/upstream_resolver.go index c75400bc1..c3cecced3 100644 --- a/resolver/upstream_resolver.go +++ b/resolver/upstream_resolver.go @@ -218,7 +218,7 @@ func newUpstreamResolverUnchecked(upstream config.Upstream, bootstrap *Bootstrap // Configuration return current resolver configuration func (r *UpstreamResolver) Configuration() (result []string) { - return + return []string{r.String()} } func (r UpstreamResolver) String() string { diff --git a/resolver/upstream_resolver_test.go b/resolver/upstream_resolver_test.go index 2000b8af2..092f066c4 100644 --- a/resolver/upstream_resolver_test.go +++ b/resolver/upstream_resolver_test.go @@ -206,12 +206,12 @@ var _ = Describe("UpstreamResolver", Label("upstreamResolver"), func() { }) Describe("Configuration", func() { When("Configuration is called", func() { - It("should return nil, because upstream resolver is printed out by other resolvers", func() { + It("should return configuration", func() { sut := newUpstreamResolverUnchecked(config.Upstream{}, nil) c := sut.Configuration() - Expect(c).Should(BeNil()) + Expect(len(c)).Should(BeNumerically(">=", 1)) }) }) })