tailscale/net/interfaces/interfaces_test.go

// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package interfaces

import (
	"encoding/json"
	"net"
	"net/netip"
	"testing"
)

func TestGetState(t *testing.T) {
	st, err := GetState()
	if err != nil {
		t.Fatal(err)
	}
	j, err := json.MarshalIndent(st, "", "\t")
	if err != nil {
		t.Errorf("JSON: %v", err)
	}
	t.Logf("Got: %s", j)
	t.Logf("As string: %s", st)

	st2, err := GetState()
	if err != nil {
		t.Fatal(err)
	}

	if !st.EqualFiltered(st2, UseAllInterfaces, UseAllIPs) {
		// let's assume nobody was changing the system network interfaces between
		// the two GetState calls.
		t.Fatal("two States back-to-back were not equal")
	}

	t.Logf("As string:\n\t%s", st)
}

func TestLikelyHomeRouterIP(t *testing.T) {
	gw, my, ok := LikelyHomeRouterIP()
	if !ok {
		t.Logf("no result")
		return
	}
	t.Logf("myIP = %v; gw = %v", my, gw)
}

func TestIsUsableV6(t *testing.T) {
	tests := []struct {
		name string
		ip   string
		want bool
	}{
		{"first ULA", "fc00::1", true},
		{"Tailscale", "fd7a:115c:a1e0::1", false},
		{"Cloud Run", "fddf:3978:feb1:d745::1", true},
		{"zeros", "0000:0000:0000:0000:0000:0000:0000:0000", false},
		{"Link Local", "fe80::1", false},
		{"Global", "2602::1", true},
		{"IPv4 public", "192.0.2.1", false},
		{"IPv4 private", "192.168.1.1", false},
	}

	for _, test := range tests {
		if got := isUsableV6(netip.MustParseAddr(test.ip)); got != test.want {
			t.Errorf("isUsableV6(%s) = %v, want %v", test.name, got, test.want)
		}
	}
}

func TestStateEqualFilteredIPFilter(t *testing.T) {
	// s1 and s2 are identical, except that an "interesting" interface
	// has gained an "uninteresting" IP address.

	s1 := &State{
		InterfaceIPs: map[string][]netip.Prefix{"x": {
			netip.MustParsePrefix("42.0.0.0/8"),
			netip.MustParsePrefix("169.254.0.0/16"), // link local unicast
		}},
		Interface: map[string]Interface{"x": {Interface: &net.Interface{Name: "x"}}},
	}

	s2 := &State{
		InterfaceIPs: map[string][]netip.Prefix{"x": {
			netip.MustParsePrefix("42.0.0.0/8"),
			netip.MustParsePrefix("169.254.0.0/16"), // link local unicast
			netip.MustParsePrefix("127.0.0.0/8"),    // loopback (added)
		}},
		Interface: map[string]Interface{"x": {Interface: &net.Interface{Name: "x"}}},
	}

	// s1 and s2 are different...
	if s1.EqualFiltered(s2, UseAllInterfaces, UseAllIPs) {
		t.Errorf("%+v != %+v", s1, s2)
	}
	// ...and they look different if you only restrict to interesting interfaces...
	if s1.EqualFiltered(s2, UseInterestingInterfaces, UseAllIPs) {
		t.Errorf("%+v != %+v when restricting to interesting interfaces _but not_ IPs", s1, s2)
	}
	// ...but because the additional IP address is uninteresting, we should treat them as the same.
	if !s1.EqualFiltered(s2, UseInterestingInterfaces, UseInterestingIPs) {
		t.Errorf("%+v == %+v when restricting to interesting interfaces and IPs", s1, s2)
	}
}

func TestStateString(t *testing.T) {
	tests := []struct {
		name string
		s    *State
		want string
	}{
		{
			name: "typical_linux",
			s: &State{
				DefaultRouteInterface: "eth0",
				Interface: map[string]Interface{
					"eth0": {
						Interface: &net.Interface{
							Flags: net.FlagUp,
						},
					},
					"wlan0": {
						Interface: &net.Interface{},
					},
				},
				InterfaceIPs: map[string][]netip.Prefix{
					"eth0": []netip.Prefix{
						netip.MustParsePrefix("10.0.0.2/8"),
					},
				},
				HaveV4: true,
			},
			want: `interfaces.State{defaultRoute=eth0 ifs={eth0:[10.0.0.2/8]} v4=true v6=false}`,
		},
		{
			name: "default_desc",
			s: &State{
				DefaultRouteInterface: "foo",
				Interface: map[string]Interface{
					"foo": {
						Desc: "a foo thing",
					},
				},
			},
			want: `interfaces.State{defaultRoute=foo (a foo thing) ifs={} v4=false v6=false}`,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.s.String()
			if got != tt.want {
				t.Errorf("wrong\n got: %s\nwant: %s\n", got, tt.want)
			}
		})
	}
}