fix: ensure conditional upstreams initialize independently of default upstreams (#1890)

Fixes #1639 where conditional DNS mappings would fail with "Not Ready"
errors when the default upstream was unreachable, even though conditional
upstreams have their own independent DNS servers.

The issue occurred when using `upstreams.init.strategy: fast`, where
conditional upstreams inherited the async initialization behavior. If
default upstreams were unreachable during this initialization window,
ALL queries (including conditional ones) would fail.

Changes:
- Conditional upstreams now always use blocking initialization regardless
  of the global init strategy
- This ensures conditional DNS mappings are fully ready before accepting
  queries and can resolve independently of default upstream status
- Updated test expectations to reflect the new resilient behavior

Impact:
Users with conditional DNS mappings (e.g., `local.dev: 192.168.1.1`)
will now have reliable local DNS resolution even when their primary
internet upstreams are down or unreachable.

Author: 0xERR0R

resolver/conditional_upstream_resolver.go

@@ -30,9 +30,15 @@ func NewConditionalUpstreamResolver(
 
 	for domain, upstreams := range cfg.Mapping.Upstreams {
 		name := fmt.Sprintf("<conditional in %s>", domain)
-		cfg := config.NewUpstreamGroup(name, upstreamsCfg, upstreams)
+		groupCfg := config.NewUpstreamGroup(name, upstreamsCfg, upstreams)
 
-		r, err := NewParallelBestResolver(ctx, cfg, bootstrap)
+		// Override init strategy for conditional upstreams to always use blocking initialization.
+		// This ensures conditional upstreams are always ready to resolve their domains,
+		// even if the default upstream is unreachable during async initialization.
+		// See: https://github.com/0xERR0R/blocky/issues/1639
+		groupCfg.Init.Strategy = config.InitStrategyBlocking
+
+		r, err := NewParallelBestResolver(ctx, groupCfg, bootstrap)
 		if err != nil {
 			return nil, err
 		}

resolver/conditional_upstream_resolver_test.go

@@ -193,7 +193,7 @@ var _ = Describe("ConditionalUpstreamResolver", Label("conditionalResolver"), fu
 	})
 
 	When("upstream is invalid", func() {
-		It("errors during construction", func() {
+		It("succeeds with bootstrap resolver during construction", func() {
 			b := newTestBootstrap(ctx, &dns.Msg{MsgHdr: dns.MsgHdr{Rcode: dns.RcodeServerFailure}})
 
 			upstreamsCfg := defaultUpstreamsConfig
@@ -207,9 +207,12 @@ var _ = Describe("ConditionalUpstreamResolver", Label("conditionalResolver"), fu
 				},
 			}
 
+			// Conditional upstreams should always succeed during construction to ensure
+			// they remain available even when default upstreams are unreachable.
+			// See: https://github.com/0xERR0R/blocky/issues/1639
 			r, err := NewConditionalUpstreamResolver(ctx, sutConfig, upstreamsCfg, b)
-			Expect(err).Should(HaveOccurred())
-			Expect(r).Should(BeNil())
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(r).ShouldNot(BeNil())
 		})
 	})