Merge pull request #14006 from baude/pkgsignalspecgenutilunittests

Unit tests for pkg/specgenutil pkg/signal

pkg/signal/signal_common_test.go

@@ -0,0 +1,120 @@
+package signal
+
+import (
+	"syscall"
+	"testing"
+)
+
+func TestParseSignal(t *testing.T) {
+	type args struct {
+		rawSignal string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    syscall.Signal
+		wantErr bool
+	}{
+		{
+			name: "KILL to SIGKILL",
+			args: args{
+				rawSignal: "KILL",
+			},
+			want:    syscall.SIGKILL,
+			wantErr: false,
+		},
+		{
+			name: "Case doesnt matter",
+			args: args{
+				rawSignal: "kIlL",
+			},
+			want:    syscall.SIGKILL,
+			wantErr: false,
+		},
+		{
+			name: "Garbage signal",
+			args: args{
+				rawSignal: "FOO",
+			},
+			want:    -1,
+			wantErr: true,
+		},
+		{
+			name: "Signal with prepended SIG",
+			args: args{
+				rawSignal: "SIGKILL",
+			},
+			want:    syscall.SIGKILL,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseSignal(tt.args.rawSignal)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseSignal() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("ParseSignal() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseSignalNameOrNumber(t *testing.T) {
+	type args struct {
+		rawSignal string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    syscall.Signal
+		wantErr bool
+	}{
+		{
+			name: "Kill should work",
+			args: args{
+				rawSignal: "kill",
+			},
+			want:    syscall.SIGKILL,
+			wantErr: false,
+		},
+		{
+			name: "9 for kill should work",
+			args: args{
+				rawSignal: "9",
+			},
+			want:    syscall.SIGKILL,
+			wantErr: false,
+		},
+		{
+			name: "Non-defined signal number should work",
+			args: args{
+				rawSignal: "923",
+			},
+			want:    923,
+			wantErr: false,
+		},
+		{
+			name: "garbage should fail",
+			args: args{
+				rawSignal: "foo",
+			},
+			want:    -1,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseSignalNameOrNumber(tt.args.rawSignal)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseSignalNameOrNumber() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("ParseSignalNameOrNumber() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/specgenutil/ports_test.go

@@ -0,0 +1,57 @@
+package specgenutil
+
+import "testing"
+
+func Test_verifyExpose(t *testing.T) {
+	type args struct {
+		expose []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "single port with tcp",
+			args: args{
+				expose: []string{"53/tcp"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "single port with udp",
+			args: args{
+				expose: []string{"53/udp"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "good port range",
+			args: args{
+				expose: []string{"100-133"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "high to low should fail",
+			args: args{
+				expose: []string{"100-99"},
+			},
+			wantErr: true,
+		},
+		{
+			name: "range with protocol",
+			args: args{
+				expose: []string{"53/tcp-55/tcp"},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := verifyExpose(tt.args.expose); (err != nil) != tt.wantErr {
+				t.Errorf("verifyExpose() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

pkg/specgenutil/util_test.go

@@ -0,0 +1,146 @@
+package specgenutil
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCreateExpose(t *testing.T) {
+	single := make(map[uint16]string, 0)
+	single[99] = "tcp"
+
+	simpleRange := make(map[uint16]string, 0)
+	simpleRange[99] = "tcp"
+	simpleRange[100] = "tcp"
+
+	simpleRangeUDP := make(map[uint16]string, 0)
+	simpleRangeUDP[99] = "udp"
+	simpleRangeUDP[100] = "udp"
+	type args struct {
+		expose []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    map[uint16]string
+		wantErr bool
+	}{
+		{
+			name: "single port",
+			args: args{
+				expose: []string{"99"},
+			},
+			want:    single,
+			wantErr: false,
+		},
+		{
+			name: "simple range tcp",
+			args: args{
+				expose: []string{"99-100"},
+			},
+			want:    simpleRange,
+			wantErr: false,
+		},
+		{
+			name: "simple range udp",
+			args: args{
+				expose: []string{"99-100/udp"},
+			},
+			want:    simpleRangeUDP,
+			wantErr: false,
+		},
+		{
+			name: "range inverted should fail",
+			args: args{
+				expose: []string{"100-99"},
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "specifying protocol twice should fail",
+			args: args{
+				expose: []string{"99/tcp-100/tcp"},
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := CreateExpose(tt.args.expose)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CreateExpose() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("CreateExpose() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_parseAndValidatePort(t *testing.T) {
+	type args struct {
+		port string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint16
+		wantErr bool
+	}{
+		{
+			name: "0 should fail",
+			args: args{
+				port: "0",
+			},
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "over 65535 should fail",
+			args: args{
+				port: "66666",
+			},
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "",
+			args: args{
+				port: "99",
+			},
+			want:    99,
+			wantErr: false,
+		},
+		{
+			name: "negative values should fail",
+			args: args{
+				port: "-1",
+			},
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "protocol should fail",
+			args: args{
+				port: "99/tcp",
+			},
+			want:    0,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := parseAndValidatePort(tt.args.port)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parseAndValidatePort() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("parseAndValidatePort() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/specgenutil/volumes_test.go

@@ -0,0 +1,68 @@
+package specgenutil
+
+import "testing"
+
+func Test_validChownFlag(t *testing.T) {
+	type args struct {
+		flag string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    bool
+		wantErr bool
+	}{
+		{
+			name: "U true",
+			args: args{
+				flag: "U=true",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "U true case doesnt matter",
+			args: args{
+				flag: "u=True",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "U is false",
+			args: args{
+				flag: "U=false",
+			},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "chown should also work",
+			args: args{
+				flag: "chown=true",
+			},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "garbage value should fail",
+			args: args{
+				flag: "U=foobar",
+			},
+			want:    false,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := validChownFlag(tt.args.flag)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validChownFlag() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("validChownFlag() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}