github.com/leoh0/docker@v1.6.0-rc4/daemon/networkdriver/portmapper/mapper_test.go (about)

     1  package portmapper
     2  
     3  import (
     4  	"net"
     5  	"testing"
     6  
     7  	"github.com/docker/docker/pkg/iptables"
     8  )
     9  
    10  func init() {
    11  	// override this func to mock out the proxy server
    12  	NewProxy = NewMockProxyCommand
    13  }
    14  
    15  func TestSetIptablesChain(t *testing.T) {
    16  	pm := New()
    17  
    18  	c := &iptables.Chain{
    19  		Name:   "TEST",
    20  		Bridge: "192.168.1.1",
    21  	}
    22  
    23  	if pm.chain != nil {
    24  		t.Fatal("chain should be nil at init")
    25  	}
    26  
    27  	pm.SetIptablesChain(c)
    28  	if pm.chain == nil {
    29  		t.Fatal("chain should not be nil after set")
    30  	}
    31  }
    32  
    33  func TestMapPorts(t *testing.T) {
    34  	pm := New()
    35  	dstIp1 := net.ParseIP("192.168.0.1")
    36  	dstIp2 := net.ParseIP("192.168.0.2")
    37  	dstAddr1 := &net.TCPAddr{IP: dstIp1, Port: 80}
    38  	dstAddr2 := &net.TCPAddr{IP: dstIp2, Port: 80}
    39  
    40  	srcAddr1 := &net.TCPAddr{Port: 1080, IP: net.ParseIP("172.16.0.1")}
    41  	srcAddr2 := &net.TCPAddr{Port: 1080, IP: net.ParseIP("172.16.0.2")}
    42  
    43  	addrEqual := func(addr1, addr2 net.Addr) bool {
    44  		return (addr1.Network() == addr2.Network()) && (addr1.String() == addr2.String())
    45  	}
    46  
    47  	if host, err := pm.Map(srcAddr1, dstIp1, 80); err != nil {
    48  		t.Fatalf("Failed to allocate port: %s", err)
    49  	} else if !addrEqual(dstAddr1, host) {
    50  		t.Fatalf("Incorrect mapping result: expected %s:%s, got %s:%s",
    51  			dstAddr1.String(), dstAddr1.Network(), host.String(), host.Network())
    52  	}
    53  
    54  	if _, err := pm.Map(srcAddr1, dstIp1, 80); err == nil {
    55  		t.Fatalf("Port is in use - mapping should have failed")
    56  	}
    57  
    58  	if _, err := pm.Map(srcAddr2, dstIp1, 80); err == nil {
    59  		t.Fatalf("Port is in use - mapping should have failed")
    60  	}
    61  
    62  	if _, err := pm.Map(srcAddr2, dstIp2, 80); err != nil {
    63  		t.Fatalf("Failed to allocate port: %s", err)
    64  	}
    65  
    66  	if pm.Unmap(dstAddr1) != nil {
    67  		t.Fatalf("Failed to release port")
    68  	}
    69  
    70  	if pm.Unmap(dstAddr2) != nil {
    71  		t.Fatalf("Failed to release port")
    72  	}
    73  
    74  	if pm.Unmap(dstAddr2) == nil {
    75  		t.Fatalf("Port already released, but no error reported")
    76  	}
    77  }
    78  
    79  func TestGetUDPKey(t *testing.T) {
    80  	addr := &net.UDPAddr{IP: net.ParseIP("192.168.1.5"), Port: 53}
    81  
    82  	key := getKey(addr)
    83  
    84  	if expected := "192.168.1.5:53/udp"; key != expected {
    85  		t.Fatalf("expected key %s got %s", expected, key)
    86  	}
    87  }
    88  
    89  func TestGetTCPKey(t *testing.T) {
    90  	addr := &net.TCPAddr{IP: net.ParseIP("192.168.1.5"), Port: 80}
    91  
    92  	key := getKey(addr)
    93  
    94  	if expected := "192.168.1.5:80/tcp"; key != expected {
    95  		t.Fatalf("expected key %s got %s", expected, key)
    96  	}
    97  }
    98  
    99  func TestGetUDPIPAndPort(t *testing.T) {
   100  	addr := &net.UDPAddr{IP: net.ParseIP("192.168.1.5"), Port: 53}
   101  
   102  	ip, port := getIPAndPort(addr)
   103  	if expected := "192.168.1.5"; ip.String() != expected {
   104  		t.Fatalf("expected ip %s got %s", expected, ip)
   105  	}
   106  
   107  	if ep := 53; port != ep {
   108  		t.Fatalf("expected port %d got %d", ep, port)
   109  	}
   110  }
   111  
   112  func TestMapAllPortsSingleInterface(t *testing.T) {
   113  	pm := New()
   114  	dstIp1 := net.ParseIP("0.0.0.0")
   115  	srcAddr1 := &net.TCPAddr{Port: 1080, IP: net.ParseIP("172.16.0.1")}
   116  
   117  	hosts := []net.Addr{}
   118  	var host net.Addr
   119  	var err error
   120  
   121  	defer func() {
   122  		for _, val := range hosts {
   123  			pm.Unmap(val)
   124  		}
   125  	}()
   126  
   127  	for i := 0; i < 10; i++ {
   128  		start, end := pm.Allocator.Begin, pm.Allocator.End
   129  		for i := start; i < end; i++ {
   130  			if host, err = pm.Map(srcAddr1, dstIp1, 0); err != nil {
   131  				t.Fatal(err)
   132  			}
   133  
   134  			hosts = append(hosts, host)
   135  		}
   136  
   137  		if _, err := pm.Map(srcAddr1, dstIp1, start); err == nil {
   138  			t.Fatalf("Port %d should be bound but is not", start)
   139  		}
   140  
   141  		for _, val := range hosts {
   142  			if err := pm.Unmap(val); err != nil {
   143  				t.Fatal(err)
   144  			}
   145  		}
   146  
   147  		hosts = []net.Addr{}
   148  	}
   149  }