podman

1
//go:build !remote
2

3
package generate
4

5
import (
6
	"net"
7

8
	"github.com/containers/common/libnetwork/types"
9
	"github.com/containers/podman/v5/pkg/specgen"
10
	"github.com/stretchr/testify/assert"
11
	"github.com/stretchr/testify/require"
12

13
	"testing"
14
)
15

16
var (
17
	portMappings = []types.PortMapping{{HostPort: 443, ContainerPort: 8080, Protocol: protoUDP}, {HostPort: 22, ContainerPort: 2222, Protocol: protoTCP}}
18
	networks     = map[string]types.PerNetworkOptions{"test": {
19
		StaticIPs:     nil,
20
		Aliases:       nil,
21
		StaticMAC:     nil,
22
		InterfaceName: "eth2",
23
	}}
24
)
25

26
func TestMapSpecCopyPodSpecToInfraContainerSpec(t *testing.T) {
27
	infraCommand := []string{"top"}
28
	addedHosts := []string{"otherhost"}
29
	dnsServers := []net.IP{net.IPv4(10, 0, 0, 1), net.IPv4(8, 8, 8, 8)}
30
	dnsOptions := []string{"dns option"}
31
	dnsSearch := []string{"dns search"}
32
	infraImage := "someimage"
33
	conmonPidFile := "/var/run/conmon.pid"
34
	podSpec := specgen.PodSpecGenerator{
35
		PodBasicConfig: specgen.PodBasicConfig{InfraCommand: infraCommand, InfraImage: infraImage,
36
			InfraConmonPidFile: conmonPidFile},
37
		PodNetworkConfig: specgen.PodNetworkConfig{
38
			PortMappings: portMappings, HostAdd: addedHosts, DNSServer: dnsServers, DNSOption: dnsOptions, DNSSearch: dnsSearch,
39
			Networks: networks, NoManageResolvConf: true, NoManageHosts: true},
40
		PodCgroupConfig:    specgen.PodCgroupConfig{},
41
		PodResourceConfig:  specgen.PodResourceConfig{},
42
		PodStorageConfig:   specgen.PodStorageConfig{},
43
		PodSecurityConfig:  specgen.PodSecurityConfig{},
44
		InfraContainerSpec: &specgen.SpecGenerator{},
45
		ServiceContainerID: "",
46
	}
47

48
	mappedSpec, err := MapSpec(&podSpec)
49

50
	assert.NoError(t, err)
51

52
	assert.Equal(t, portMappings, mappedSpec.PortMappings)
53
	assert.Equal(t, infraCommand, mappedSpec.Entrypoint)
54
	assert.Equal(t, addedHosts, mappedSpec.HostAdd)
55
	assert.Equal(t, dnsServers, mappedSpec.DNSServers)
56
	assert.Equal(t, dnsOptions, mappedSpec.DNSOptions)
57
	assert.Equal(t, dnsSearch, mappedSpec.DNSSearch)
58
	require.NotNil(t, mappedSpec.UseImageResolvConf)
59
	assert.True(t, *mappedSpec.UseImageResolvConf)
60
	assert.Equal(t, networks, mappedSpec.Networks)
61
	require.NotNil(t, mappedSpec.UseImageHosts)
62
	assert.True(t, *mappedSpec.UseImageHosts)
63
	assert.Equal(t, conmonPidFile, mappedSpec.ConmonPidFile)
64
	assert.Equal(t, infraImage, mappedSpec.Image)
65
}
66

67
func createPodSpec(mode specgen.NamespaceMode) specgen.PodSpecGenerator {
68
	return specgen.PodSpecGenerator{
69
		InfraContainerSpec: &specgen.SpecGenerator{},
70
		PodNetworkConfig: specgen.PodNetworkConfig{
71
			NetNS: specgen.Namespace{NSMode: mode},
72
		},
73
	}
74
}
75

76
func createPodSpecWithNetworks(mode specgen.NamespaceMode) specgen.PodSpecGenerator {
77
	spec := createPodSpec(mode)
78
	spec.InfraContainerSpec.Networks = networks
79
	return spec
80
}
81

82
func createPodSpecWithPortMapping(mode specgen.NamespaceMode) specgen.PodSpecGenerator {
83
	spec := createPodSpec(mode)
84
	spec.InfraContainerSpec.PortMappings = portMappings
85
	return spec
86
}
87

88
func createPodSpecWithNetNsPath(path string) specgen.PodSpecGenerator {
89
	spec := createPodSpec(specgen.Path)
90
	spec.NetNS.Value = path
91
	return spec
92
}
93

94
func TestMapSpecNetworkOptions(t *testing.T) {
95
	tests := []struct {
96
		name                   string
97
		podSpec                specgen.PodSpecGenerator
98
		expectedNSMode         specgen.NamespaceMode
99
		expectedNSValue        string
100
		expectedNetworkOptions map[string][]string
101
		mustError              bool
102
	}{
103
		{
104
			name:           "Default",
105
			podSpec:        createPodSpec(specgen.Default),
106
			expectedNSMode: "",
107
		},
108
		{
109
			name:           "Bridge",
110
			podSpec:        createPodSpec(specgen.Bridge),
111
			expectedNSMode: specgen.Bridge,
112
		},
113
		{
114
			name:           "Private",
115
			podSpec:        createPodSpec(specgen.Private),
116
			expectedNSMode: specgen.Private,
117
		}, {
118
			name:           "Host",
119
			podSpec:        createPodSpec(specgen.Host),
120
			expectedNSMode: specgen.Host,
121
		},
122
		{
123
			name:      "Host but with port mappings",
124
			podSpec:   createPodSpecWithPortMapping(specgen.Host),
125
			mustError: true,
126
		}, {
127
			name:      "Host but with networks",
128
			podSpec:   createPodSpecWithNetworks(specgen.Host),
129
			mustError: true,
130
		},
131
		{
132
			name:           "Slirp",
133
			podSpec:        createPodSpec(specgen.Slirp),
134
			expectedNSMode: specgen.Slirp,
135
		},
136
		{
137
			name: "Slirp but if infra spec NS mode is Host",
138
			podSpec: specgen.PodSpecGenerator{
139
				InfraContainerSpec: &specgen.SpecGenerator{
140
					ContainerNetworkConfig: specgen.ContainerNetworkConfig{NetNS: specgen.Namespace{NSMode: host}},
141
				},
142
				PodNetworkConfig: specgen.PodNetworkConfig{
143
					NetNS: specgen.Namespace{NSMode: specgen.Slirp},
144
				},
145
			},
146
			expectedNSMode: specgen.Host,
147
		},
148
		{
149
			name:            "Path",
150
			podSpec:         createPodSpecWithNetNsPath("/var/run/netns/bla"),
151
			expectedNSMode:  specgen.Path,
152
			expectedNSValue: "/var/run/netns/bla",
153
		},
154
		{
155
			name:           "NoNetwork",
156
			podSpec:        createPodSpec(specgen.NoNetwork),
157
			expectedNSMode: specgen.NoNetwork,
158
		},
159
		{
160
			name:      "NoNetwork but with networks",
161
			podSpec:   createPodSpecWithNetworks(specgen.NoNetwork),
162
			mustError: true,
163
		},
164
		{
165
			name:      "NoNetwork but with port mappings",
166
			podSpec:   createPodSpecWithPortMapping(specgen.NoNetwork),
167
			mustError: true,
168
		},
169
		{
170
			name:      "FromContainer",
171
			podSpec:   createPodSpec(specgen.FromContainer),
172
			mustError: true,
173
		}, {
174
			name:      "FromPod",
175
			podSpec:   createPodSpec(specgen.FromPod),
176
			mustError: true,
177
		},
178
	}
179

180
	for _, tt := range tests {
181
		t.Run(tt.name, func(t *testing.T) {
182
			mappedSpec, err := MapSpec(&tt.podSpec)
183

184
			if tt.mustError {
185
				assert.Error(t, err)
186
			} else {
187
				assert.NoError(t, err, "error is not nil")
188
				assert.Equal(t, tt.expectedNSMode, mappedSpec.NetNS.NSMode)
189
				assert.Equal(t, tt.expectedNSValue, mappedSpec.NetNS.Value)
190
				assert.Equal(t, tt.expectedNetworkOptions, mappedSpec.NetworkOptions)
191
			}
192
		})
193
	}
194
}
195