github.com/nginxinc/kubernetes-ingress@v1.12.5/cmd/nginx-ingress/main_test.go (about)

     1  package main
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"testing"
     7  	"time"
     8  )
     9  
    10  func TestValidatePort(t *testing.T) {
    11  	badPorts := []int{80, 443, 1, 1023, 65536}
    12  	for _, badPort := range badPorts {
    13  		err := validatePort(badPort)
    14  		if err == nil {
    15  			t.Errorf("Expected error for port %v\n", badPort)
    16  		}
    17  	}
    18  
    19  	goodPorts := []int{8080, 8081, 8082, 1024, 65535}
    20  	for _, goodPort := range goodPorts {
    21  		err := validatePort(goodPort)
    22  		if err != nil {
    23  			t.Errorf("Error for valid port:  %v err: %v\n", goodPort, err)
    24  		}
    25  	}
    26  
    27  }
    28  
    29  func TestParseNginxStatusAllowCIDRs(t *testing.T) {
    30  	var badCIDRs = []struct {
    31  		input         string
    32  		expectedError error
    33  	}{
    34  		{
    35  			"earth, ,,furball",
    36  			errors.New("invalid IP address: earth"),
    37  		},
    38  		{
    39  			"127.0.0.1,10.0.1.0/24, ,,furball",
    40  			errors.New("invalid CIDR address: an empty string is an invalid CIDR block or IP address"),
    41  		},
    42  		{
    43  			"false",
    44  			errors.New("invalid IP address: false"),
    45  		},
    46  	}
    47  	for _, badCIDR := range badCIDRs {
    48  		_, err := parseNginxStatusAllowCIDRs(badCIDR.input)
    49  		if err == nil {
    50  			t.Errorf("parseNginxStatusAllowCIDRs(%q) returned no error when it should have returned error %q", badCIDR.input, badCIDR.expectedError)
    51  		} else if err.Error() != badCIDR.expectedError.Error() {
    52  			t.Errorf("parseNginxStatusAllowCIDRs(%q) returned error %q when it should have returned error %q", badCIDR.input, err, badCIDR.expectedError)
    53  		}
    54  	}
    55  
    56  	var goodCIDRs = []struct {
    57  		input    string
    58  		expected []string
    59  	}{
    60  		{
    61  			"127.0.0.1",
    62  			[]string{"127.0.0.1"},
    63  		},
    64  		{
    65  			"10.0.1.0/24",
    66  			[]string{"10.0.1.0/24"},
    67  		},
    68  		{
    69  			"127.0.0.1,10.0.1.0/24,68.121.233.214 , 24.24.24.24/32",
    70  			[]string{"127.0.0.1", "10.0.1.0/24", "68.121.233.214", "24.24.24.24/32"},
    71  		},
    72  	}
    73  	for _, goodCIDR := range goodCIDRs {
    74  		result, err := parseNginxStatusAllowCIDRs(goodCIDR.input)
    75  		if err != nil {
    76  			t.Errorf("parseNginxStatusAllowCIDRs(%q) returned an error when it should have returned no error: %q", goodCIDR.input, err)
    77  		}
    78  
    79  		if !reflect.DeepEqual(result, goodCIDR.expected) {
    80  			t.Errorf("parseNginxStatusAllowCIDRs(%q) returned %v expected %v: ", goodCIDR.input, result, goodCIDR.expected)
    81  		}
    82  	}
    83  }
    84  
    85  func TestValidateCIDRorIP(t *testing.T) {
    86  	badCIDRs := []string{"localhost", "thing", "~", "!!!", "", " ", "-1"}
    87  	for _, badCIDR := range badCIDRs {
    88  		err := validateCIDRorIP(badCIDR)
    89  		if err == nil {
    90  			t.Errorf(`Expected error for invalid CIDR "%v"\n`, badCIDR)
    91  		}
    92  	}
    93  
    94  	goodCIDRs := []string{"0.0.0.0/32", "0.0.0.0/0", "127.0.0.1/32", "127.0.0.0/24", "23.232.65.42"}
    95  	for _, goodCIDR := range goodCIDRs {
    96  		err := validateCIDRorIP(goodCIDR)
    97  		if err != nil {
    98  			t.Errorf("Error for valid CIDR: %v err: %v\n", goodCIDR, err)
    99  		}
   100  	}
   101  }
   102  
   103  func TestValidateLocation(t *testing.T) {
   104  	badLocations := []string{
   105  		"",
   106  		"/",
   107  		" /test",
   108  		"/bad;",
   109  	}
   110  	for _, badLocation := range badLocations {
   111  		err := validateLocation(badLocation)
   112  		if err == nil {
   113  			t.Errorf("validateLocation(%v) returned no error when it should have returned an error", badLocation)
   114  		}
   115  	}
   116  
   117  	goodLocations := []string{
   118  		"/test",
   119  		"/test/subtest",
   120  	}
   121  	for _, goodLocation := range goodLocations {
   122  		err := validateLocation(goodLocation)
   123  		if err != nil {
   124  			t.Errorf("validateLocation(%v) returned an error when it should have returned no error: %v", goodLocation, err)
   125  		}
   126  	}
   127  }
   128  
   129  func TestParseReloadTimeout(t *testing.T) {
   130  	tests := []struct {
   131  		timeout           int
   132  		appProtectEnabled bool
   133  		expected          time.Duration
   134  	}{
   135  		{
   136  			timeout:           0,
   137  			appProtectEnabled: true,
   138  			expected:          20000 * time.Millisecond,
   139  		},
   140  		{
   141  			timeout:           0,
   142  			appProtectEnabled: false,
   143  			expected:          4000 * time.Millisecond,
   144  		},
   145  		{
   146  			timeout:           1000,
   147  			appProtectEnabled: true,
   148  			expected:          1000 * time.Millisecond,
   149  		},
   150  		{
   151  			timeout:           1000,
   152  			appProtectEnabled: false,
   153  			expected:          1000 * time.Millisecond,
   154  		},
   155  	}
   156  
   157  	for _, test := range tests {
   158  		result := parseReloadTimeout(test.appProtectEnabled, test.timeout)
   159  		if result != test.expected {
   160  			t.Errorf("parseReloadTimeout(%v, %v) returned %v but expected %v", test.appProtectEnabled, test.timeout, result, test.expected)
   161  		}
   162  	}
   163  }