Source file src/net/dnsconfig_unix_test.go

Documentation: net

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
     6  
     7  package net
     8  
     9  import (
    10  	"errors"
    11  	"os"
    12  	"reflect"
    13  	"strings"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  var dnsReadConfigTests = []struct {
    19  	name string
    20  	want *dnsConfig
    21  }{
    22  	{
    23  		name: "testdata/resolv.conf",
    24  		want: &dnsConfig{
    25  			servers:    []string{"8.8.8.8:53", "[2001:4860:4860::8888]:53", "[fe80::1%lo0]:53"},
    26  			search:     []string{"localdomain."},
    27  			ndots:      5,
    28  			timeout:    10 * time.Second,
    29  			attempts:   3,
    30  			rotate:     true,
    31  			unknownOpt: true, // the "options attempts 3" line
    32  		},
    33  	},
    34  	{
    35  		name: "testdata/domain-resolv.conf",
    36  		want: &dnsConfig{
    37  			servers:  []string{"8.8.8.8:53"},
    38  			search:   []string{"localdomain."},
    39  			ndots:    1,
    40  			timeout:  5 * time.Second,
    41  			attempts: 2,
    42  		},
    43  	},
    44  	{
    45  		name: "testdata/search-resolv.conf",
    46  		want: &dnsConfig{
    47  			servers:  []string{"8.8.8.8:53"},
    48  			search:   []string{"test.", "invalid."},
    49  			ndots:    1,
    50  			timeout:  5 * time.Second,
    51  			attempts: 2,
    52  		},
    53  	},
    54  	{
    55  		name: "testdata/empty-resolv.conf",
    56  		want: &dnsConfig{
    57  			servers:  defaultNS,
    58  			ndots:    1,
    59  			timeout:  5 * time.Second,
    60  			attempts: 2,
    61  			search:   []string{"domain.local."},
    62  		},
    63  	},
    64  	{
    65  		name: "testdata/invalid-ndots-resolv.conf",
    66  		want: &dnsConfig{
    67  			servers:  defaultNS,
    68  			ndots:    0,
    69  			timeout:  5 * time.Second,
    70  			attempts: 2,
    71  			search:   []string{"domain.local."},
    72  		},
    73  	},
    74  	{
    75  		name: "testdata/large-ndots-resolv.conf",
    76  		want: &dnsConfig{
    77  			servers:  defaultNS,
    78  			ndots:    15,
    79  			timeout:  5 * time.Second,
    80  			attempts: 2,
    81  			search:   []string{"domain.local."},
    82  		},
    83  	},
    84  	{
    85  		name: "testdata/negative-ndots-resolv.conf",
    86  		want: &dnsConfig{
    87  			servers:  defaultNS,
    88  			ndots:    0,
    89  			timeout:  5 * time.Second,
    90  			attempts: 2,
    91  			search:   []string{"domain.local."},
    92  		},
    93  	},
    94  	{
    95  		name: "testdata/openbsd-resolv.conf",
    96  		want: &dnsConfig{
    97  			ndots:    1,
    98  			timeout:  5 * time.Second,
    99  			attempts: 2,
   100  			lookup:   []string{"file", "bind"},
   101  			servers:  []string{"169.254.169.254:53", "10.240.0.1:53"},
   102  			search:   []string{"c.symbolic-datum-552.internal."},
   103  		},
   104  	},
   105  	{
   106  		name: "testdata/single-request-resolv.conf",
   107  		want: &dnsConfig{
   108  			servers:       defaultNS,
   109  			ndots:         1,
   110  			singleRequest: true,
   111  			timeout:       5 * time.Second,
   112  			attempts:      2,
   113  			search:        []string{"domain.local."},
   114  		},
   115  	},
   116  	{
   117  		name: "testdata/single-request-reopen-resolv.conf",
   118  		want: &dnsConfig{
   119  			servers:       defaultNS,
   120  			ndots:         1,
   121  			singleRequest: true,
   122  			timeout:       5 * time.Second,
   123  			attempts:      2,
   124  			search:        []string{"domain.local."},
   125  		},
   126  	},
   127  	{
   128  		name: "testdata/linux-use-vc-resolv.conf",
   129  		want: &dnsConfig{
   130  			servers:  defaultNS,
   131  			ndots:    1,
   132  			useTCP:   true,
   133  			timeout:  5 * time.Second,
   134  			attempts: 2,
   135  			search:   []string{"domain.local."},
   136  		},
   137  	},
   138  	{
   139  		name: "testdata/freebsd-usevc-resolv.conf",
   140  		want: &dnsConfig{
   141  			servers:  defaultNS,
   142  			ndots:    1,
   143  			useTCP:   true,
   144  			timeout:  5 * time.Second,
   145  			attempts: 2,
   146  			search:   []string{"domain.local."},
   147  		},
   148  	},
   149  	{
   150  		name: "testdata/openbsd-tcp-resolv.conf",
   151  		want: &dnsConfig{
   152  			servers:  defaultNS,
   153  			ndots:    1,
   154  			useTCP:   true,
   155  			timeout:  5 * time.Second,
   156  			attempts: 2,
   157  			search:   []string{"domain.local."},
   158  		},
   159  	},
   160  }
   161  
   162  func TestDNSReadConfig(t *testing.T) {
   163  	origGetHostname := getHostname
   164  	defer func() { getHostname = origGetHostname }()
   165  	getHostname = func() (string, error) { return "host.domain.local", nil }
   166  
   167  	for _, tt := range dnsReadConfigTests {
   168  		conf := dnsReadConfig(tt.name)
   169  		if conf.err != nil {
   170  			t.Fatal(conf.err)
   171  		}
   172  		conf.mtime = time.Time{}
   173  		if !reflect.DeepEqual(conf, tt.want) {
   174  			t.Errorf("%s:\ngot: %+v\nwant: %+v", tt.name, conf, tt.want)
   175  		}
   176  	}
   177  }
   178  
   179  func TestDNSReadMissingFile(t *testing.T) {
   180  	origGetHostname := getHostname
   181  	defer func() { getHostname = origGetHostname }()
   182  	getHostname = func() (string, error) { return "host.domain.local", nil }
   183  
   184  	conf := dnsReadConfig("a-nonexistent-file")
   185  	if !os.IsNotExist(conf.err) {
   186  		t.Errorf("missing resolv.conf:\ngot: %v\nwant: %v", conf.err, os.ErrNotExist)
   187  	}
   188  	conf.err = nil
   189  	want := &dnsConfig{
   190  		servers:  defaultNS,
   191  		ndots:    1,
   192  		timeout:  5 * time.Second,
   193  		attempts: 2,
   194  		search:   []string{"domain.local."},
   195  	}
   196  	if !reflect.DeepEqual(conf, want) {
   197  		t.Errorf("missing resolv.conf:\ngot: %+v\nwant: %+v", conf, want)
   198  	}
   199  }
   200  
   201  var dnsDefaultSearchTests = []struct {
   202  	name string
   203  	err  error
   204  	want []string
   205  }{
   206  	{
   207  		name: "host.long.domain.local",
   208  		want: []string{"long.domain.local."},
   209  	},
   210  	{
   211  		name: "host.local",
   212  		want: []string{"local."},
   213  	},
   214  	{
   215  		name: "host",
   216  		want: nil,
   217  	},
   218  	{
   219  		name: "host.domain.local",
   220  		err:  errors.New("errored"),
   221  		want: nil,
   222  	},
   223  	{
   224  		// ensures we don't return []string{""}
   225  		// which causes duplicate lookups
   226  		name: "foo.",
   227  		want: nil,
   228  	},
   229  }
   230  
   231  func TestDNSDefaultSearch(t *testing.T) {
   232  	origGetHostname := getHostname
   233  	defer func() { getHostname = origGetHostname }()
   234  
   235  	for _, tt := range dnsDefaultSearchTests {
   236  		getHostname = func() (string, error) { return tt.name, tt.err }
   237  		got := dnsDefaultSearch()
   238  		if !reflect.DeepEqual(got, tt.want) {
   239  			t.Errorf("dnsDefaultSearch with hostname %q and error %+v = %q, wanted %q", tt.name, tt.err, got, tt.want)
   240  		}
   241  	}
   242  }
   243  
   244  func TestDNSNameLength(t *testing.T) {
   245  	origGetHostname := getHostname
   246  	defer func() { getHostname = origGetHostname }()
   247  	getHostname = func() (string, error) { return "host.domain.local", nil }
   248  
   249  	var char63 = ""
   250  	for i := 0; i < 63; i++ {
   251  		char63 += "a"
   252  	}
   253  	longDomain := strings.Repeat(char63+".", 5) + "example"
   254  
   255  	for _, tt := range dnsReadConfigTests {
   256  		conf := dnsReadConfig(tt.name)
   257  		if conf.err != nil {
   258  			t.Fatal(conf.err)
   259  		}
   260  
   261  		var shortestSuffix int
   262  		for _, suffix := range tt.want.search {
   263  			if shortestSuffix == 0 || len(suffix) < shortestSuffix {
   264  				shortestSuffix = len(suffix)
   265  			}
   266  		}
   267  
   268  		// Test a name that will be maximally long when prefixing the shortest
   269  		// suffix (accounting for the intervening dot).
   270  		longName := longDomain[len(longDomain)-254+1+shortestSuffix:]
   271  		if longName[0] == '.' || longName[1] == '.' {
   272  			longName = "aa." + longName[3:]
   273  		}
   274  		for _, fqdn := range conf.nameList(longName) {
   275  			if len(fqdn) > 254 {
   276  				t.Errorf("got %d; want less than or equal to 254", len(fqdn))
   277  			}
   278  		}
   279  
   280  		// Now test a name that's too long for suffixing.
   281  		unsuffixable := "a." + longName[1:]
   282  		unsuffixableResults := conf.nameList(unsuffixable)
   283  		if len(unsuffixableResults) != 1 {
   284  			t.Errorf("suffixed names %v; want []", unsuffixableResults[1:])
   285  		}
   286  
   287  		// Now test a name that's too long for DNS.
   288  		tooLong := "a." + longDomain
   289  		tooLongResults := conf.nameList(tooLong)
   290  		if tooLongResults != nil {
   291  			t.Errorf("suffixed names %v; want nil", tooLongResults)
   292  		}
   293  	}
   294  }
   295  

View as plain text