github.com/netdata/go.d.plugin@v0.58.1/pkg/iprange/parse_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package iprange
     4  
     5  import (
     6  	"fmt"
     7  	"net"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestParseRanges(t *testing.T) {
    14  	tests := map[string]struct {
    15  		input      string
    16  		wantRanges []Range
    17  		wantErr    bool
    18  	}{
    19  		"single range": {
    20  			input: "192.0.2.0-192.0.2.10",
    21  			wantRanges: []Range{
    22  				prepareRange("192.0.2.0", "192.0.2.10"),
    23  			},
    24  		},
    25  		"multiple ranges": {
    26  			input: "2001:db8::0 192.0.2.0-192.0.2.10 2001:db8::0/126 192.0.2.0/255.255.255.0",
    27  			wantRanges: []Range{
    28  				prepareRange("2001:db8::0", "2001:db8::0"),
    29  				prepareRange("192.0.2.0", "192.0.2.10"),
    30  				prepareRange("2001:db8::1", "2001:db8::2"),
    31  				prepareRange("192.0.2.1", "192.0.2.254"),
    32  			},
    33  		},
    34  		"single invalid syntax": {
    35  			input:   "192.0.2.0-192.0.2.",
    36  			wantErr: true,
    37  		},
    38  		"multiple invalid syntax": {
    39  			input:   "2001:db8::0 192.0.2.0-192.0.2.10 2001:db8::0/999 192.0.2.0/255.255.255.0",
    40  			wantErr: true,
    41  		},
    42  	}
    43  
    44  	for name, test := range tests {
    45  		t.Run(name, func(t *testing.T) {
    46  			rs, err := ParseRanges(test.input)
    47  
    48  			if test.wantErr {
    49  				assert.Error(t, err)
    50  				assert.Nilf(t, rs, "want: nil, got: %s", rs)
    51  			} else {
    52  				assert.NoError(t, err)
    53  				assert.Equalf(t, test.wantRanges, rs, "want: %s, got: %s", test.wantRanges, rs)
    54  			}
    55  		})
    56  	}
    57  }
    58  
    59  func TestParseRange(t *testing.T) {
    60  	tests := map[string]struct {
    61  		input     string
    62  		wantRange Range
    63  		wantErr   bool
    64  	}{
    65  		"v4 IP": {
    66  			input:     "192.0.2.0",
    67  			wantRange: prepareRange("192.0.2.0", "192.0.2.0"),
    68  		},
    69  		"v4 IP: invalid address": {
    70  			input:   "192.0.2.",
    71  			wantErr: true,
    72  		},
    73  		"v4 Range": {
    74  			input:     "192.0.2.0-192.0.2.10",
    75  			wantRange: prepareRange("192.0.2.0", "192.0.2.10"),
    76  		},
    77  		"v4 Range: start == end": {
    78  			input:     "192.0.2.0-192.0.2.0",
    79  			wantRange: prepareRange("192.0.2.0", "192.0.2.0"),
    80  		},
    81  		"v4 Range: start > end": {
    82  			input:   "192.0.2.10-192.0.2.0",
    83  			wantErr: true,
    84  		},
    85  		"v4 Range: invalid start": {
    86  			input:   "192.0.2.-192.0.2.10",
    87  			wantErr: true,
    88  		},
    89  		"v4 Range: invalid end": {
    90  			input:   "192.0.2.0-192.0.2.",
    91  			wantErr: true,
    92  		},
    93  		"v4 Range: v6 start": {
    94  			input:   "2001:db8::0-192.0.2.10",
    95  			wantErr: true,
    96  		},
    97  		"v4 Range: v6 end": {
    98  			input:   "192.0.2.0-2001:db8::0",
    99  			wantErr: true,
   100  		},
   101  		"v4 CIDR: /0": {
   102  			input:     "192.0.2.0/0",
   103  			wantRange: prepareRange("0.0.0.1", "255.255.255.254"),
   104  		},
   105  		"v4 CIDR: /24": {
   106  			input:     "192.0.2.0/24",
   107  			wantRange: prepareRange("192.0.2.1", "192.0.2.254"),
   108  		},
   109  		"v4 CIDR: /30": {
   110  			input:     "192.0.2.0/30",
   111  			wantRange: prepareRange("192.0.2.1", "192.0.2.2"),
   112  		},
   113  		"v4 CIDR: /31": {
   114  			input:     "192.0.2.0/31",
   115  			wantRange: prepareRange("192.0.2.0", "192.0.2.1"),
   116  		},
   117  		"v4 CIDR: /32": {
   118  			input:     "192.0.2.0/32",
   119  			wantRange: prepareRange("192.0.2.0", "192.0.2.0"),
   120  		},
   121  		"v4 CIDR: ip instead of host address": {
   122  			input:     "192.0.2.10/24",
   123  			wantRange: prepareRange("192.0.2.1", "192.0.2.254"),
   124  		},
   125  		"v4 CIDR: missing prefix length": {
   126  			input:   "192.0.2.0/",
   127  			wantErr: true,
   128  		},
   129  		"v4 CIDR: invalid prefix length": {
   130  			input:   "192.0.2.0/99",
   131  			wantErr: true,
   132  		},
   133  		"v4 Mask: /0": {
   134  			input:     "192.0.2.0/0.0.0.0",
   135  			wantRange: prepareRange("0.0.0.1", "255.255.255.254"),
   136  		},
   137  		"v4 Mask: /24": {
   138  			input:     "192.0.2.0/255.255.255.0",
   139  			wantRange: prepareRange("192.0.2.1", "192.0.2.254"),
   140  		},
   141  		"v4 Mask: /30": {
   142  			input:     "192.0.2.0/255.255.255.252",
   143  			wantRange: prepareRange("192.0.2.1", "192.0.2.2"),
   144  		},
   145  		"v4 Mask: /31": {
   146  			input:     "192.0.2.0/255.255.255.254",
   147  			wantRange: prepareRange("192.0.2.0", "192.0.2.1"),
   148  		},
   149  		"v4 Mask: /32": {
   150  			input:     "192.0.2.0/255.255.255.255",
   151  			wantRange: prepareRange("192.0.2.0", "192.0.2.0"),
   152  		},
   153  		"v4 Mask: missing prefix mask": {
   154  			input:   "192.0.2.0/",
   155  			wantErr: true,
   156  		},
   157  		"v4 Mask: invalid mask": {
   158  			input:   "192.0.2.0/mask",
   159  			wantErr: true,
   160  		},
   161  		"v4 Mask: not canonical form mask": {
   162  			input:   "192.0.2.0/255.255.0.254",
   163  			wantErr: true,
   164  		},
   165  		"v4 Mask: v6 address": {
   166  			input:   "2001:db8::/255.255.255.0",
   167  			wantErr: true,
   168  		},
   169  
   170  		"v6 IP": {
   171  			input:     "2001:db8::0",
   172  			wantRange: prepareRange("2001:db8::0", "2001:db8::0"),
   173  		},
   174  		"v6 IP: invalid address": {
   175  			input:   "2001:db8",
   176  			wantErr: true,
   177  		},
   178  		"v6 Range": {
   179  			input:     "2001:db8::-2001:db8::10",
   180  			wantRange: prepareRange("2001:db8::", "2001:db8::10"),
   181  		},
   182  		"v6 Range: start == end": {
   183  			input:     "2001:db8::-2001:db8::",
   184  			wantRange: prepareRange("2001:db8::", "2001:db8::"),
   185  		},
   186  		"v6 Range: start > end": {
   187  			input:   "2001:db8::10-2001:db8::",
   188  			wantErr: true,
   189  		},
   190  		"v6 Range: invalid start": {
   191  			input:   "2001:db8-2001:db8::10",
   192  			wantErr: true,
   193  		},
   194  		"v6 Range: invalid end": {
   195  			input:   "2001:db8::-2001:db8",
   196  			wantErr: true,
   197  		},
   198  		"v6 Range: v4 start": {
   199  			input:   "192.0.2.0-2001:db8::10",
   200  			wantErr: true,
   201  		},
   202  		"v6 Range: v4 end": {
   203  			input:   "2001:db8::-192.0.2.10",
   204  			wantErr: true,
   205  		},
   206  		"v6 CIDR: /0": {
   207  			input:     "2001:db8::/0",
   208  			wantRange: prepareRange("::1", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"),
   209  		},
   210  		"v6 CIDR: /64": {
   211  			input:     "2001:db8::/64",
   212  			wantRange: prepareRange("2001:db8::1", "2001:db8::ffff:ffff:ffff:fffe"),
   213  		},
   214  		"v6 CIDR: /126": {
   215  			input:     "2001:db8::/126",
   216  			wantRange: prepareRange("2001:db8::1", "2001:db8::2"),
   217  		},
   218  		"v6 CIDR: /127": {
   219  			input:     "2001:db8::/127",
   220  			wantRange: prepareRange("2001:db8::", "2001:db8::1"),
   221  		},
   222  		"v6 CIDR: /128": {
   223  			input:     "2001:db8::/128",
   224  			wantRange: prepareRange("2001:db8::", "2001:db8::"),
   225  		},
   226  		"v6 CIDR: ip instead of host address": {
   227  			input:     "2001:db8::10/64",
   228  			wantRange: prepareRange("2001:db8::1", "2001:db8::ffff:ffff:ffff:fffe"),
   229  		},
   230  		"v6 CIDR: missing prefix length": {
   231  			input:   "2001:db8::/",
   232  			wantErr: true,
   233  		},
   234  		"v6 CIDR: invalid prefix length": {
   235  			input:   "2001:db8::/999",
   236  			wantErr: true,
   237  		},
   238  	}
   239  
   240  	for name, test := range tests {
   241  		name = fmt.Sprintf("%s (%s)", name, test.input)
   242  		t.Run(name, func(t *testing.T) {
   243  			r, err := ParseRange(test.input)
   244  
   245  			if test.wantErr {
   246  				assert.Error(t, err)
   247  				assert.Nilf(t, r, "want: nil, got: %s", r)
   248  			} else {
   249  				assert.NoError(t, err)
   250  				assert.Equalf(t, test.wantRange, r, "want: %s, got: %s", test.wantRange, r)
   251  			}
   252  		})
   253  	}
   254  }
   255  
   256  func prepareRange(start, end string) Range {
   257  	return New(net.ParseIP(start), net.ParseIP(end))
   258  }