github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/pkg/specgenutil/util_test.go (about)

     1  package specgenutil
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func TestCreateExpose(t *testing.T) {
     9  	single := make(map[uint16]string, 0)
    10  	single[99] = "tcp"
    11  
    12  	simpleRange := make(map[uint16]string, 0)
    13  	simpleRange[99] = "tcp"
    14  	simpleRange[100] = "tcp"
    15  
    16  	simpleRangeUDP := make(map[uint16]string, 0)
    17  	simpleRangeUDP[99] = "udp"
    18  	simpleRangeUDP[100] = "udp"
    19  	type args struct {
    20  		expose []string
    21  	}
    22  	tests := []struct {
    23  		name    string
    24  		args    args
    25  		want    map[uint16]string
    26  		wantErr bool
    27  	}{
    28  		{
    29  			name: "single port",
    30  			args: args{
    31  				expose: []string{"99"},
    32  			},
    33  			want:    single,
    34  			wantErr: false,
    35  		},
    36  		{
    37  			name: "simple range tcp",
    38  			args: args{
    39  				expose: []string{"99-100"},
    40  			},
    41  			want:    simpleRange,
    42  			wantErr: false,
    43  		},
    44  		{
    45  			name: "simple range udp",
    46  			args: args{
    47  				expose: []string{"99-100/udp"},
    48  			},
    49  			want:    simpleRangeUDP,
    50  			wantErr: false,
    51  		},
    52  		{
    53  			name: "range inverted should fail",
    54  			args: args{
    55  				expose: []string{"100-99"},
    56  			},
    57  			want:    nil,
    58  			wantErr: true,
    59  		},
    60  		{
    61  			name: "specifying protocol twice should fail",
    62  			args: args{
    63  				expose: []string{"99/tcp-100/tcp"},
    64  			},
    65  			want:    nil,
    66  			wantErr: true,
    67  		},
    68  	}
    69  	for _, tt := range tests {
    70  		t.Run(tt.name, func(t *testing.T) {
    71  			got, err := CreateExpose(tt.args.expose)
    72  			if (err != nil) != tt.wantErr {
    73  				t.Errorf("CreateExpose() error = %v, wantErr %v", err, tt.wantErr)
    74  				return
    75  			}
    76  			if !reflect.DeepEqual(got, tt.want) {
    77  				t.Errorf("CreateExpose() got = %v, want %v", got, tt.want)
    78  			}
    79  		})
    80  	}
    81  }
    82  
    83  func Test_parseAndValidatePort(t *testing.T) {
    84  	type args struct {
    85  		port string
    86  	}
    87  	tests := []struct {
    88  		name    string
    89  		args    args
    90  		want    uint16
    91  		wantErr bool
    92  	}{
    93  		{
    94  			name: "0 should fail",
    95  			args: args{
    96  				port: "0",
    97  			},
    98  			want:    0,
    99  			wantErr: true,
   100  		},
   101  		{
   102  			name: "over 65535 should fail",
   103  			args: args{
   104  				port: "66666",
   105  			},
   106  			want:    0,
   107  			wantErr: true,
   108  		},
   109  		{
   110  			name: "",
   111  			args: args{
   112  				port: "99",
   113  			},
   114  			want:    99,
   115  			wantErr: false,
   116  		},
   117  		{
   118  			name: "negative values should fail",
   119  			args: args{
   120  				port: "-1",
   121  			},
   122  			want:    0,
   123  			wantErr: true,
   124  		},
   125  		{
   126  			name: "protocol should fail",
   127  			args: args{
   128  				port: "99/tcp",
   129  			},
   130  			want:    0,
   131  			wantErr: true,
   132  		},
   133  	}
   134  	for _, tt := range tests {
   135  		t.Run(tt.name, func(t *testing.T) {
   136  			got, err := parseAndValidatePort(tt.args.port)
   137  			if (err != nil) != tt.wantErr {
   138  				t.Errorf("parseAndValidatePort() error = %v, wantErr %v", err, tt.wantErr)
   139  				return
   140  			}
   141  			if got != tt.want {
   142  				t.Errorf("parseAndValidatePort() got = %v, want %v", got, tt.want)
   143  			}
   144  		})
   145  	}
   146  }