podman

1
package utils_test
2

3
import (
4
	"encoding/json"
5
	"fmt"
6
	"io"
7
	"os"
8
	"reflect"
9
	"strings"
10

11
	. "github.com/containers/podman/v5/test/utils"
12
	. "github.com/onsi/ginkgo/v2"
13
	. "github.com/onsi/gomega"
14
)
15

16
var _ = Describe("Common functions test", func() {
17
	var defaultOSPath string
18
	var defaultCgroupPath string
19

20
	BeforeEach(func() {
21
		defaultOSPath = OSReleasePath
22
		defaultCgroupPath = ProcessOneCgroupPath
23
	})
24

25
	AfterEach(func() {
26
		OSReleasePath = defaultOSPath
27
		ProcessOneCgroupPath = defaultCgroupPath
28
	})
29

30
	It("Test CreateTempDirInTempDir", func() {
31
		tmpDir, _ := CreateTempDirInTempDir()
32
		_, err := os.Stat(tmpDir)
33
		Expect(os.IsNotExist(err)).ShouldNot(BeTrue(), "Directory is not created as expect")
34
	})
35

36
	It("Test SystemExec", func() {
37
		session := SystemExec(GoechoPath, []string{})
38
		Expect(session.Command.Process).ShouldNot(BeNil(), "SystemExec cannot start a process")
39
	})
40

41
	DescribeTable("Test GetHostDistributionInfo",
42
		func(path, id, ver string, empty bool) {
43
			txt := fmt.Sprintf("ID=%s\nVERSION_ID=%s", id, ver)
44
			if !empty {
45
				f, _ := os.Create(path)
46
				_, err := f.WriteString(txt)
47
				Expect(err).ToNot(HaveOccurred(), "Failed to write data.")
48
				f.Close()
49
			}
50

51
			OSReleasePath = path
52
			host := GetHostDistributionInfo()
53
			if empty {
54
				Expect(host).To(Equal(HostOS{}), "HostOs should be empty.")
55
			} else {
56
				Expect(host.Distribution).To(Equal(strings.Trim(id, "\"")))
57
				Expect(host.Version).To(Equal(strings.Trim(ver, "\"")))
58
			}
59
		},
60
		Entry("Configure file is not exist.", "/tmp/nonexistent", "", "", true),
61
		Entry("Item value with and without \"", "/tmp/os-release.test", "fedora", "\"28\"", false),
62
		Entry("Item empty with and without \"", "/tmp/os-release.test", "", "\"\"", false),
63
	)
64

65
	DescribeTable("Test IsKernelNewerThan",
66
		func(kv string, expect, isNil bool) {
67
			newer, err := IsKernelNewerThan(kv)
68
			Expect(newer).To(Equal(expect), "Version compare results is not as expect.")
69
			Expect(err == nil).To(Equal(isNil), "Error is not as expect.")
70
		},
71
		Entry("Invalid kernel version: 0", "0", false, false),
72
		Entry("Older kernel version:0.0", "0.0", true, true),
73
		Entry("Newer kernel version: 100.17.14", "100.17.14", false, true),
74
		Entry("Invalid kernel version: I am not a kernel version", "I am not a kernel version", false, false),
75
	)
76

77
	DescribeTable("Test TestIsCommandAvailable",
78
		func(cmd string, expect bool) {
79
			cmdExist := IsCommandAvailable(cmd)
80
			Expect(cmdExist).To(Equal(expect))
81
		},
82
		Entry("Command exist", GoechoPath, true),
83
		Entry("Command exist", "Fakecmd", false),
84
	)
85

86
	It("Test WriteJSONFile", func() {
87
		type testJSON struct {
88
			Item1 int
89
			Item2 []string
90
		}
91
		compareData := &testJSON{}
92

93
		testData := &testJSON{
94
			Item1: 5,
95
			Item2: []string{"test"},
96
		}
97

98
		testByte, err := json.Marshal(testData)
99
		Expect(err).ToNot(HaveOccurred(), "Failed to marshal data.")
100

101
		err = WriteJSONFile(testByte, "/tmp/testJSON")
102
		Expect(err).ToNot(HaveOccurred(), "Failed to write JSON to file.")
103

104
		read, err := os.Open("/tmp/testJSON")
105
		Expect(err).ToNot(HaveOccurred(), "Can not find the JSON file after we write it.")
106
		defer read.Close()
107

108
		bytes, err := io.ReadAll(read)
109
		Expect(err).ToNot(HaveOccurred())
110
		err = json.Unmarshal(bytes, compareData)
111
		Expect(err).ToNot(HaveOccurred())
112

113
		Expect(reflect.DeepEqual(testData, compareData)).To(BeTrue(), "Data changed after we store it to file.")
114
	})
115

116
	DescribeTable("Test Containerized",
117
		func(path string, setEnv, createFile, expect bool) {
118
			if setEnv && (os.Getenv("container") == "") {
119
				os.Setenv("container", "test")
120
				defer os.Setenv("container", "")
121
			}
122
			if !setEnv && (os.Getenv("container") != "") {
123
				containerized := os.Getenv("container")
124
				os.Setenv("container", "")
125
				defer os.Setenv("container", containerized)
126
			}
127
			txt := "1:test:/"
128
			if expect {
129
				txt = "2:docker:/"
130
			}
131
			if createFile {
132
				f, _ := os.Create(path)
133
				_, err := f.WriteString(txt)
134
				Expect(err).ToNot(HaveOccurred(), "Failed to write data.")
135
				f.Close()
136
			}
137
			ProcessOneCgroupPath = path
138
			Expect(Containerized()).To(Equal(expect))
139
		},
140
		Entry("Set container in env", "", true, false, true),
141
		Entry("Can not read from file", "/tmp/nonexistent", false, false, false),
142
		Entry("Docker in cgroup file", "/tmp/cgroup.test", false, true, true),
143
		Entry("Docker not in cgroup file", "/tmp/cgroup.test", false, true, false),
144
	)
145

146
	It("Test WriteRSAKeyPair", func() {
147
		fileName := "/tmp/test_key"
148
		bitSize := 1024
149

150
		publicKeyFileName, privateKeyFileName, err := WriteRSAKeyPair(fileName, bitSize)
151
		Expect(err).ToNot(HaveOccurred(), "Failed to write RSA key pair to files.")
152

153
		read, err := os.Open(publicKeyFileName)
154
		Expect(err).ToNot(HaveOccurred(), "Cannot find the public key file after we write it.")
155
		defer read.Close()
156

157
		read, err = os.Open(privateKeyFileName)
158
		Expect(err).ToNot(HaveOccurred(), "Cannot find the private key file after we write it.")
159
		defer read.Close()
160
	})
161

162
})
163