github.com/aporeto-inc/trireme-lib@v10.358.0+incompatible/utils/ipprefix/ipprefix_test.go (about)

     1  // +build !windows
     2  
     3  package ipprefix
     4  
     5  import (
     6  	"fmt"
     7  	"net"
     8  	"testing"
     9  
    10  	"github.com/magiconair/properties/assert"
    11  )
    12  
    13  const (
    14  	mask24  = "24mask"
    15  	mask32  = "32mask"
    16  	mask128 = "128mask"
    17  	mask0   = "mask0"
    18  )
    19  
    20  func TestPutGetV4(t *testing.T) {
    21  	ipcache := NewIPCache()
    22  
    23  	ip := net.ParseIP("10.0.0.1")
    24  	ipcache.Put(ip, 32, mask32)
    25  	ipcache.Put(ip, 24, mask24)
    26  	ipcache.Put(ip, 0, mask0)
    27  
    28  	val, ok := ipcache.Get(ip, 32)
    29  	assert.Equal(t, ok, true, "Get should return Success")
    30  	assert.Equal(t, val.(string), mask32, fmt.Sprintf("Returned value should be %s", mask32))
    31  	val, ok = ipcache.Get(net.ParseIP("10.0.0.2"), 24)
    32  	assert.Equal(t, ok, true, "Get should return Success")
    33  	assert.Equal(t, val.(string), mask24, fmt.Sprintf("Returned value should be %s", mask24))
    34  
    35  	_, ok = ipcache.Get(net.ParseIP("8.8.8.8"), 0)
    36  	assert.Equal(t, ok, true, "should be found in cache")
    37  
    38  	_, ok = ipcache.Get(ip, 10)
    39  	assert.Equal(t, ok, false, "Get should return nil")
    40  
    41  	ipcache.Put(ip, 32, nil)
    42  	_, ok = ipcache.Get(ip, 32)
    43  	assert.Equal(t, ok, false, "Should not be found in cache")
    44  }
    45  
    46  func TestPutGetV6(t *testing.T) {
    47  	ipcache := NewIPCache()
    48  
    49  	ip := net.ParseIP("8000::220")
    50  	ipcache.Put(ip, 128, mask128)
    51  	ipcache.Put(ip, 24, mask24)
    52  	ipcache.Put(ip, 0, mask0)
    53  
    54  	val, ok := ipcache.Get(ip, 128)
    55  	assert.Equal(t, ok, true, "Get should return success")
    56  	assert.Equal(t, val.(string), mask128, fmt.Sprintf("Returned value should be %s", mask128))
    57  	val, ok = ipcache.Get(ip, 24)
    58  	assert.Equal(t, ok, true, "Get should return success")
    59  	assert.Equal(t, val.(string), mask24, fmt.Sprintf("Returned value should be %s", mask24))
    60  
    61  	_, ok = ipcache.Get(net.ParseIP("abcd::200"), 0)
    62  	assert.Equal(t, ok, true, "Get should return success")
    63  
    64  	_, ok = ipcache.Get(ip, 10)
    65  	assert.Equal(t, ok, false, "Get should return nil")
    66  
    67  	ipcache.Put(ip, 128, nil)
    68  	_, ok = ipcache.Get(ip, 128)
    69  	assert.Equal(t, ok, false, "Get should return nil")
    70  }
    71  
    72  func TestRunIPV4(t *testing.T) {
    73  	var found bool
    74  
    75  	ipcache := NewIPCache()
    76  
    77  	ip := net.ParseIP("10.0.0.1")
    78  	ipcache.Put(ip, 32, mask32)
    79  	ipcache.Put(ip, 24, mask24)
    80  
    81  	testRunIP := func(val interface{}) bool {
    82  		found = false
    83  		if val != nil {
    84  			str := val.(string)
    85  
    86  			if str == mask32 {
    87  				found = true
    88  			}
    89  		}
    90  		return true
    91  	}
    92  
    93  	ipcache.RunFuncOnLpmIP(ip, testRunIP)
    94  	assert.Equal(t, found, true, "found should be true")
    95  }
    96  
    97  func TestRunIPv6(t *testing.T) {
    98  
    99  	var found bool
   100  
   101  	ipcache := NewIPCache()
   102  
   103  	ip := net.ParseIP("8000::220")
   104  	ipcache.Put(ip, 128, mask128)
   105  	ipcache.Put(ip, 24, mask24)
   106  
   107  	testRunIP := func(val interface{}) bool {
   108  		found = false
   109  		if val != nil {
   110  			str := val.(string)
   111  
   112  			if str == mask128 {
   113  				found = true
   114  			}
   115  		}
   116  		return true
   117  	}
   118  
   119  	ipcache.RunFuncOnLpmIP(ip, testRunIP)
   120  	assert.Equal(t, found, true, "found should be true")
   121  }
   122  
   123  func TestRunValIPv4(t *testing.T) {
   124  
   125  	ipcache := NewIPCache()
   126  
   127  	ip := net.ParseIP("10.0.0.1")
   128  	ipcache.Put(ip, 32, mask32)
   129  	ipcache.Put(ip, 24, mask24)
   130  
   131  	m := map[string]bool{}
   132  	m[mask32] = true
   133  	m[mask24] = true
   134  
   135  	testRunVal := func(val interface{}) interface{} {
   136  		if val != nil {
   137  			s := val.(string)
   138  			if s == mask32 {
   139  				delete(m, s)
   140  				return nil
   141  			}
   142  		}
   143  
   144  		return val
   145  	}
   146  
   147  	ipcache.RunFuncOnVals(testRunVal)
   148  	assert.Equal(t, len(m), 1, "map should be of length 0")
   149  	_, ok := ipcache.Get(ip, 32)
   150  	assert.Equal(t, ok, false, "Get should return nil")
   151  	_, ok = ipcache.Get(ip, 24)
   152  	assert.Equal(t, ok, true, "Get should return true")
   153  
   154  }
   155  
   156  func TestRunValIPv6(t *testing.T) {
   157  
   158  	ipcache := NewIPCache()
   159  
   160  	ip := net.ParseIP("8000::220")
   161  	ipcache.Put(ip, 128, mask128)
   162  	ipcache.Put(ip, 24, mask24)
   163  
   164  	m := map[string]bool{}
   165  	m[mask128] = true
   166  	m[mask24] = true
   167  
   168  	testRunVal := func(val interface{}) interface{} {
   169  		if val != nil {
   170  			s := val.(string)
   171  			if s == mask128 {
   172  				delete(m, s)
   173  				return nil
   174  			}
   175  		}
   176  
   177  		return val
   178  	}
   179  
   180  	ipcache.RunFuncOnVals(testRunVal)
   181  	assert.Equal(t, len(m), 1, "map should be of length 0")
   182  	_, ok := ipcache.Get(ip, 128)
   183  	assert.Equal(t, ok, false, "Get should return nil")
   184  	_, ok = ipcache.Get(ip, 24)
   185  	assert.Equal(t, ok, true, "Get should return true")
   186  }