コード例 #1
0
        public void ShouldResolveExactMatchWithAlias()
        {
            string testExpectedHostname = "example.com";
            string testalias = "IIS1";
            string testExpectedResult = "iis1.example.com";

            DnsRuleGroup group = new DnsRuleGroup();
            group.AddRule(new DnsRule
                              {
                                  Hostnames = new[] { (Hostname)testExpectedHostname },
                                  RecordType = DnsRecordType.CNAME,
                                  ValueAlias = testalias
                              });

            DnsValueAlias alias = new DnsValueAlias { Name = testalias, Value = testExpectedResult };

            RuleResolver resolver = new RuleResolver(new DnsRuleGroup[] { group },
                                                     new DnsValueAlias[] { alias });

            QueryResult result = resolver.Resolve(new Query
                                                      {
                                                          QueryType = DnsRecordType.CNAME,
                                                          Question = testExpectedHostname
                                                      });

            Assert.That(result, Is.Not.Null);
            Assert.That(result.Result, Is.True);
            Assert.That(result.RecordType, Is.EqualTo(DnsRecordType.CNAME));
            Assert.That(result.RecordValue, Is.EqualTo(testExpectedResult));
        }
コード例 #2
0
        public void ShouldResolveMorePreciseHostnameInGroup()
        {
            string testHostnameMatch = "www.example.com";
            string testExpectedResult = "iis3.example.com";

            string testHostnameEntry1 = "*.example.com";
            string testHostnameReturnValue1 = "iis1.example.com";

            string testHostnameEntry2 = testHostnameMatch;
            string testHostnameReturnValue2 = testExpectedResult;

            DnsRuleGroup group = new DnsRuleGroup();
            group.AddRule(new DnsRule
                              {
                                  Hostnames = new[] { (Hostname)testHostnameEntry1 },
                                  RecordType = DnsRecordType.CNAME,
                                  Value = testHostnameReturnValue1
                              });

            group.AddRule(new DnsRule
                              {
                                  Hostnames = new[] { (Hostname)testHostnameEntry2 },
                                  RecordType = DnsRecordType.CNAME,
                                  Value = testHostnameReturnValue2
                              });

            RuleResolver resolver = new RuleResolver(new DnsRuleGroup[] { group },
                                                     new DnsValueAlias[] { });

            QueryResult result = resolver.Resolve(new Query
                                                      {
                                                          QueryType = DnsRecordType.CNAME,
                                                          Question = testHostnameMatch
                                                      });

            Assert.That(result, Is.Not.Null);
            Assert.That(result.Result, Is.True);
            Assert.That(result.RecordType, Is.EqualTo(DnsRecordType.CNAME));
            Assert.That(result.RecordValue, Is.EqualTo(testExpectedResult));
        }
コード例 #3
0
        public void ShouldReturnResolveUpstreamForAnyHostMatch()
        {
            string testHostnameMatch = "www.example.com";
            string testHostnameEntry = "*.example.com";

            DnsRuleGroup group = new DnsRuleGroup();
            group.AddRule(new DnsRule
            {
                Hostnames = new[] { (Hostname)testHostnameEntry },
                RuleType = DnsRuleType.ResolveUpstream
            });

            RuleResolver resolver = new RuleResolver(new DnsRuleGroup[] { group },
                                                     new DnsValueAlias[] { });

            QueryResult result = resolver.Resolve(new Query
            {
                QueryType = DnsRecordType.CNAME,
                Question = testHostnameMatch
            });

            Assert.That(result, Is.Not.Null);
            Assert.That(result.Result, Is.True);
            Assert.That(result.RuleResult, Is.EqualTo(DnsRuleType.ResolveUpstream));
        }