1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
package utils_test
import (
"encoding/json"
"fmt"
"io"
"os"
"reflect"
"strings"
. "github.com/containers/podman/v5/test/utils"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
var _ = Describe("Common functions test", func() {
var defaultOSPath string
var defaultCgroupPath string
BeforeEach(func() {
defaultOSPath = OSReleasePath
defaultCgroupPath = ProcessOneCgroupPath
})
AfterEach(func() {
OSReleasePath = defaultOSPath
ProcessOneCgroupPath = defaultCgroupPath
})
It("Test SystemExec", func() {
session := SystemExec(GoechoPath, []string{})
Expect(session.Command.Process).ShouldNot(BeNil(), "SystemExec cannot start a process")
})
DescribeTable("Test GetHostDistributionInfo",
func(path, id, ver string, empty bool) {
txt := fmt.Sprintf("ID=%s\nVERSION_ID=%s", id, ver)
if !empty {
f, _ := os.Create(path)
_, err := f.WriteString(txt)
Expect(err).ToNot(HaveOccurred(), "Failed to write data.")
f.Close()
}
OSReleasePath = path
host := GetHostDistributionInfo()
if empty {
Expect(host).To(Equal(HostOS{}), "HostOs should be empty.")
} else {
Expect(host.Distribution).To(Equal(strings.Trim(id, "\"")))
Expect(host.Version).To(Equal(strings.Trim(ver, "\"")))
}
},
Entry("Configure file is not exist.", "/tmp/nonexistent", "", "", true),
Entry("Item value with and without \"", "/tmp/os-release.test", "fedora", "\"28\"", false),
Entry("Item empty with and without \"", "/tmp/os-release.test", "", "\"\"", false),
)
DescribeTable("Test TestIsCommandAvailable",
func(cmd string, expect bool) {
cmdExist := IsCommandAvailable(cmd)
Expect(cmdExist).To(Equal(expect))
},
Entry("Command exist", GoechoPath, true),
Entry("Command exist", "Fakecmd", false),
)
It("Test WriteJSONFile", func() {
type testJSON struct {
Item1 int
Item2 []string
}
compareData := &testJSON{}
testData := &testJSON{
Item1: 5,
Item2: []string{"test"},
}
testByte, err := json.Marshal(testData)
Expect(err).ToNot(HaveOccurred(), "Failed to marshal data.")
err = WriteJSONFile(testByte, "/tmp/testJSON")
Expect(err).ToNot(HaveOccurred(), "Failed to write JSON to file.")
read, err := os.Open("/tmp/testJSON")
Expect(err).ToNot(HaveOccurred(), "Can not find the JSON file after we write it.")
defer read.Close()
bytes, err := io.ReadAll(read)
Expect(err).ToNot(HaveOccurred())
err = json.Unmarshal(bytes, compareData)
Expect(err).ToNot(HaveOccurred())
Expect(reflect.DeepEqual(testData, compareData)).To(BeTrue(), "Data changed after we store it to file.")
})
DescribeTable("Test Containerized",
func(path string, setEnv, createFile, expect bool) {
if setEnv && (os.Getenv("container") == "") {
os.Setenv("container", "test")
defer os.Setenv("container", "")
}
if !setEnv && (os.Getenv("container") != "") {
containerized := os.Getenv("container")
os.Setenv("container", "")
defer os.Setenv("container", containerized)
}
txt := "1:test:/"
if expect {
txt = "2:docker:/"
}
if createFile {
f, _ := os.Create(path)
_, err := f.WriteString(txt)
Expect(err).ToNot(HaveOccurred(), "Failed to write data.")
f.Close()
}
ProcessOneCgroupPath = path
Expect(Containerized()).To(Equal(expect))
},
Entry("Set container in env", "", true, false, true),
Entry("Can not read from file", "/tmp/nonexistent", false, false, false),
Entry("Docker in cgroup file", "/tmp/cgroup.test", false, true, true),
Entry("Docker not in cgroup file", "/tmp/cgroup.test", false, true, false),
)
It("Test WriteRSAKeyPair", func() {
fileName := "/tmp/test_key"
bitSize := 1024
publicKeyFileName, privateKeyFileName, err := WriteRSAKeyPair(fileName, bitSize)
Expect(err).ToNot(HaveOccurred(), "Failed to write RSA key pair to files.")
read, err := os.Open(publicKeyFileName)
Expect(err).ToNot(HaveOccurred(), "Cannot find the public key file after we write it.")
defer read.Close()
read, err = os.Open(privateKeyFileName)
Expect(err).ToNot(HaveOccurred(), "Cannot find the private key file after we write it.")
defer read.Close()
})
})
|
