From ab5e69c442ad3df3ef12cae8c40ba6602c2cdec6 Mon Sep 17 00:00:00 2001 From: Sebastiaan van Stijn Date: Tue, 1 Nov 2022 14:57:19 +0100 Subject: [PATCH] api/types/container: rewrite tests to use subtests and asserts Signed-off-by: Sebastiaan van Stijn --- api/types/container/hostconfig_unix_test.go | 235 ++++++++------------ 1 file changed, 96 insertions(+), 139 deletions(-) diff --git a/api/types/container/hostconfig_unix_test.go b/api/types/container/hostconfig_unix_test.go index 0d378d9202..63662f241b 100644 --- a/api/types/container/hostconfig_unix_test.go +++ b/api/types/container/hostconfig_unix_test.go @@ -10,79 +10,53 @@ import ( is "gotest.tools/v3/assert/cmp" ) -func TestCgroupnsModeTest(t *testing.T) { - cgroupNsModes := map[CgroupnsMode][]bool{ - // private, host, empty, valid - "": {false, false, true, true}, - "something:weird": {false, false, false, false}, - "host": {false, true, false, true}, - "host:name": {false, false, false, false}, - "private": {true, false, false, true}, - "private:name": {false, false, false, false}, +func TestCgroupnsMode(t *testing.T) { + modes := map[CgroupnsMode]struct{ private, host, empty, valid bool }{ + "": {private: false, host: false, empty: true, valid: true}, + "something:weird": {private: false, host: false, empty: false, valid: false}, + "host": {private: false, host: true, empty: false, valid: true}, + "host:name": {private: false, host: false, empty: false, valid: false}, + "private": {private: true, host: false, empty: false, valid: true}, + "private:name": {private: false, host: false, empty: false, valid: false}, } - for cgroupNsMode, state := range cgroupNsModes { - if cgroupNsMode.IsPrivate() != state[0] { - t.Fatalf("CgroupnsMode.IsPrivate for %v should have been %v but was %v", cgroupNsMode, state[0], cgroupNsMode.IsPrivate()) - } - if cgroupNsMode.IsHost() != state[1] { - t.Fatalf("CgroupnsMode.IsHost for %v should have been %v but was %v", cgroupNsMode, state[1], cgroupNsMode.IsHost()) - } - if cgroupNsMode.IsEmpty() != state[2] { - t.Fatalf("CgroupnsMode.Valid for %v should have been %v but was %v", cgroupNsMode, state[2], cgroupNsMode.Valid()) - } - if cgroupNsMode.Valid() != state[3] { - t.Fatalf("CgroupnsMode.Valid for %v should have been %v but was %v", cgroupNsMode, state[2], cgroupNsMode.Valid()) - } + for mode, expected := range modes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.IsEmpty(), expected.empty)) + assert.Check(t, is.Equal(mode.Valid(), expected.valid)) + }) } } // TODO Windows: This will need addressing for a Windows daemon. -func TestNetworkModeTest(t *testing.T) { - networkModes := map[NetworkMode][]bool{ - // private, bridge, host, container, none, default - "": {true, false, false, false, false, false}, - "something:weird": {true, false, false, false, false, false}, - "bridge": {true, true, false, false, false, false}, - "host": {false, false, true, false, false, false}, - "container:name": {false, false, false, true, false, false}, - "none": {true, false, false, false, true, false}, - "default": {true, false, false, false, false, true}, +func TestNetworkMode(t *testing.T) { + modes := map[NetworkMode]struct { + private, bridge, host, container, none, isDefault bool + name string + }{ + "": {private: true, bridge: false, host: false, container: false, none: false, isDefault: false, name: ""}, + "something:weird": {private: true, bridge: false, host: false, container: false, none: false, isDefault: false, name: "something:weird"}, + "bridge": {private: true, bridge: true, host: false, container: false, none: false, isDefault: false, name: "bridge"}, + "host": {private: false, bridge: false, host: true, container: false, none: false, isDefault: false, name: "host"}, + "container:name": {private: false, bridge: false, host: false, container: true, none: false, isDefault: false, name: "container"}, + "none": {private: true, bridge: false, host: false, container: false, none: true, isDefault: false, name: "none"}, + "default": {private: true, bridge: false, host: false, container: false, none: false, isDefault: true, name: "default"}, } - networkModeNames := map[NetworkMode]string{ - "": "", - "something:weird": "something:weird", - "bridge": "bridge", - "host": "host", - "container:name": "container", - "none": "none", - "default": "default", - } - for networkMode, state := range networkModes { - if networkMode.IsPrivate() != state[0] { - t.Fatalf("NetworkMode.IsPrivate for %v should have been %v but was %v", networkMode, state[0], networkMode.IsPrivate()) - } - if networkMode.IsBridge() != state[1] { - t.Fatalf("NetworkMode.IsBridge for %v should have been %v but was %v", networkMode, state[1], networkMode.IsBridge()) - } - if networkMode.IsHost() != state[2] { - t.Fatalf("NetworkMode.IsHost for %v should have been %v but was %v", networkMode, state[2], networkMode.IsHost()) - } - if networkMode.IsContainer() != state[3] { - t.Fatalf("NetworkMode.IsContainer for %v should have been %v but was %v", networkMode, state[3], networkMode.IsContainer()) - } - if networkMode.IsNone() != state[4] { - t.Fatalf("NetworkMode.IsNone for %v should have been %v but was %v", networkMode, state[4], networkMode.IsNone()) - } - if networkMode.IsDefault() != state[5] { - t.Fatalf("NetworkMode.IsDefault for %v should have been %v but was %v", networkMode, state[5], networkMode.IsDefault()) - } - if networkMode.NetworkName() != networkModeNames[networkMode] { - t.Fatalf("Expected name %v, got %v", networkModeNames[networkMode], networkMode.NetworkName()) - } + for mode, expected := range modes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsBridge(), expected.bridge)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.IsContainer(), expected.container)) + assert.Check(t, is.Equal(mode.IsNone(), expected.none)) + assert.Check(t, is.Equal(mode.IsDefault(), expected.isDefault)) + assert.Check(t, is.Equal(mode.NetworkName(), expected.name)) + }) } } -func TestIpcModeTest(t *testing.T) { +func TestIpcMode(t *testing.T) { ipcModes := map[IpcMode]struct { private bool host bool @@ -103,97 +77,80 @@ func TestIpcModeTest(t *testing.T) { "shareable": {shareable: true, valid: true}, } - for ipcMode, state := range ipcModes { - assert.Check(t, is.Equal(state.private, ipcMode.IsPrivate()), "IpcMode.IsPrivate() parsing failed for %q", ipcMode) - assert.Check(t, is.Equal(state.host, ipcMode.IsHost()), "IpcMode.IsHost() parsing failed for %q", ipcMode) - assert.Check(t, is.Equal(state.container, ipcMode.IsContainer()), "IpcMode.IsContainer() parsing failed for %q", ipcMode) - assert.Check(t, is.Equal(state.shareable, ipcMode.IsShareable()), "IpcMode.IsShareable() parsing failed for %q", ipcMode) - assert.Check(t, is.Equal(state.valid, ipcMode.Valid()), "IpcMode.Valid() parsing failed for %q", ipcMode) - assert.Check(t, is.Equal(state.ctrName, ipcMode.Container()), "IpcMode.Container() parsing failed for %q", ipcMode) + for mode, expected := range ipcModes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.IsContainer(), expected.container)) + assert.Check(t, is.Equal(mode.IsShareable(), expected.shareable)) + assert.Check(t, is.Equal(mode.Valid(), expected.valid)) + assert.Check(t, is.Equal(mode.Container(), expected.ctrName)) + }) } } -func TestUTSModeTest(t *testing.T) { - utsModes := map[UTSMode][]bool{ - // private, host, valid - "": {true, false, true}, - "something:weird": {true, false, false}, - "host": {false, true, true}, - "host:name": {true, false, true}, +func TestUTSMode(t *testing.T) { + modes := map[UTSMode]struct{ private, host, valid bool }{ + "": {private: true, host: false, valid: true}, + "something:weird": {private: true, host: false, valid: false}, + "host": {private: false, host: true, valid: true}, + "host:name": {private: true, host: false, valid: true}, } - for utsMode, state := range utsModes { - if utsMode.IsPrivate() != state[0] { - t.Fatalf("UtsMode.IsPrivate for %v should have been %v but was %v", utsMode, state[0], utsMode.IsPrivate()) - } - if utsMode.IsHost() != state[1] { - t.Fatalf("UtsMode.IsHost for %v should have been %v but was %v", utsMode, state[1], utsMode.IsHost()) - } - if utsMode.Valid() != state[2] { - t.Fatalf("UtsMode.Valid for %v should have been %v but was %v", utsMode, state[2], utsMode.Valid()) - } + for mode, expected := range modes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.Valid(), expected.valid)) + }) + } } -func TestUsernsModeTest(t *testing.T) { - usrensMode := map[UsernsMode][]bool{ - // private, host, valid - "": {true, false, true}, - "something:weird": {true, false, false}, - "host": {false, true, true}, - "host:name": {true, false, true}, +func TestUsernsMode(t *testing.T) { + modes := map[UsernsMode]struct{ private, host, valid bool }{ + "": {private: true, host: false, valid: true}, + "something:weird": {private: true, host: false, valid: false}, + "host": {private: false, host: true, valid: true}, + "host:name": {private: true, host: false, valid: true}, } - for usernsMode, state := range usrensMode { - if usernsMode.IsPrivate() != state[0] { - t.Fatalf("UsernsMode.IsPrivate for %v should have been %v but was %v", usernsMode, state[0], usernsMode.IsPrivate()) - } - if usernsMode.IsHost() != state[1] { - t.Fatalf("UsernsMode.IsHost for %v should have been %v but was %v", usernsMode, state[1], usernsMode.IsHost()) - } - if usernsMode.Valid() != state[2] { - t.Fatalf("UsernsMode.Valid for %v should have been %v but was %v", usernsMode, state[2], usernsMode.Valid()) - } + for mode, expected := range modes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.Valid(), expected.valid)) + }) } } -func TestPidModeTest(t *testing.T) { - pidModes := map[PidMode][]bool{ - // private, host, valid - "": {true, false, true}, - "something:weird": {true, false, false}, - "host": {false, true, true}, - "host:name": {true, false, true}, +func TestPidMode(t *testing.T) { + modes := map[PidMode]struct{ private, host, valid bool }{ + "": {private: true, host: false, valid: true}, + "something:weird": {private: true, host: false, valid: false}, + "host": {private: false, host: true, valid: true}, + "host:name": {private: true, host: false, valid: true}, } - for pidMode, state := range pidModes { - if pidMode.IsPrivate() != state[0] { - t.Fatalf("PidMode.IsPrivate for %v should have been %v but was %v", pidMode, state[0], pidMode.IsPrivate()) - } - if pidMode.IsHost() != state[1] { - t.Fatalf("PidMode.IsHost for %v should have been %v but was %v", pidMode, state[1], pidMode.IsHost()) - } - if pidMode.Valid() != state[2] { - t.Fatalf("PidMode.Valid for %v should have been %v but was %v", pidMode, state[2], pidMode.Valid()) - } + for mode, expected := range modes { + t.Run("mode="+string(mode), func(t *testing.T) { + assert.Check(t, is.Equal(mode.IsPrivate(), expected.private)) + assert.Check(t, is.Equal(mode.IsHost(), expected.host)) + assert.Check(t, is.Equal(mode.Valid(), expected.valid)) + }) } } func TestRestartPolicy(t *testing.T) { - restartPolicies := map[RestartPolicy][]bool{ - // none, always, failure - {}: {true, false, false}, - {Name: "something", MaximumRetryCount: 0}: {false, false, false}, - {Name: "no", MaximumRetryCount: 0}: {true, false, false}, - {Name: "always", MaximumRetryCount: 0}: {false, true, false}, - {Name: "on-failure", MaximumRetryCount: 0}: {false, false, true}, + policies := map[RestartPolicy]struct{ none, always, onFailure bool }{ + {Name: "", MaximumRetryCount: 0}: {none: true, always: false, onFailure: false}, + {Name: "something", MaximumRetryCount: 0}: {none: false, always: false, onFailure: false}, + {Name: "no", MaximumRetryCount: 0}: {none: true, always: false, onFailure: false}, + {Name: "always", MaximumRetryCount: 0}: {none: false, always: true, onFailure: false}, + {Name: "on-failure", MaximumRetryCount: 0}: {none: false, always: false, onFailure: true}, } - for restartPolicy, state := range restartPolicies { - if restartPolicy.IsNone() != state[0] { - t.Fatalf("RestartPolicy.IsNone for %v should have been %v but was %v", restartPolicy, state[0], restartPolicy.IsNone()) - } - if restartPolicy.IsAlways() != state[1] { - t.Fatalf("RestartPolicy.IsAlways for %v should have been %v but was %v", restartPolicy, state[1], restartPolicy.IsAlways()) - } - if restartPolicy.IsOnFailure() != state[2] { - t.Fatalf("RestartPolicy.IsOnFailure for %v should have been %v but was %v", restartPolicy, state[2], restartPolicy.IsOnFailure()) - } + for policy, expected := range policies { + t.Run("policy="+policy.Name, func(t *testing.T) { + assert.Check(t, is.Equal(policy.IsNone(), expected.none)) + assert.Check(t, is.Equal(policy.IsAlways(), expected.always)) + assert.Check(t, is.Equal(policy.IsOnFailure(), expected.onFailure)) + }) } }