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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#!/usr/bin/env bats -*- bats -*-
#
# tests for podman system df
#
# DO NOT PARALLELIZE. All of these tests require complete control of images.
#
load helpers
function setup_file() {
# Pristine setup: no pods, containers, volumes, images
run_podman pod rm -a -f
run_podman rm -f -a -t0
run_podman volume rm -a
run_podman image rm -f -a
_prefetch $IMAGE
}
@test "podman system df - basic functionality" {
run_podman system df
is "$output" ".*Images *1 *0 " "Exactly one image"
is "$output" ".*Containers *0 *0 " "No containers"
is "$output" ".*Local Volumes *0 *0 " "No volumes"
}
@test "podman system df --format {{ json . }} functionality" {
run_podman system df --format '{{json .}}'
is "$output" '.*"TotalCount":1' "Exactly one image"
is "$output" '.*"RawSize".*"Size"' "RawSize and Size reported"
is "$output" '.*"RawReclaimable".*"Reclaimable"' "RawReclaimable and Reclaimable reported"
is "$output" '.*"Containers".*"Total":0' "Total containers reported"
is "$output" '.*"Local Volumes".*"Size":"0B"' "Total containers reported"
is "$output" '.*"Local Volumes".*"Size":"0B"' "Total containers reported"
}
@test "podman system df --format json functionality" {
# Run two dummy containers, one which exits, one which stays running
cname_stopped=c-stopped-$(safename)
cname_running=c-running-$(safename)
run_podman run --name $cname_stopped $IMAGE true
run_podman run -d --name $cname_running $IMAGE top
run_podman system df --format json
local results="$output"
# FIXME! This needs to be fiddled with every time we bump testimage.
local size=12
if [[ "$(uname -m)" = "aarch64" ]]; then
size=14
fi
# FIXME: we can't check exact RawSize or Size because every CI system
# computes a different value: 12701526, 12702113, 12706209... and
# those are all amd64. aarch64 gets 12020148, 12019561.
#
# WARNING: RawSize and Size tests may fail if $IMAGE is updated. Since
# that tends to be done yearly or less, and only by Ed, that's OK.
local tests="
Type | Images | Containers | Local Volumes
Total | 1 | 2 | 0
Active | 1 | 1 | 0
RawSize | ~${size}...... | !0 | 0
RawReclaimable | 0 | !0 | 0
Reclaimable | ~\(0%\) | ~\(50%\) | ~\(0%\)
TotalCount | 1 | 2 | 0
Size | ~${size}.*MB | !0B | 0B
"
while read -a fields; do
for i in 0 1 2;do
expect="${fields[$((i+1))]}"
actual=$(jq -r ".[$i].${fields[0]}" <<<"$results")
# Do exact-match check, unless the expect term starts with ~ or !
op='='
if [[ "$expect" =~ ^\! ]]; then
op='!='
expect=${expect##\!}
fi
if [[ "$expect" =~ ^~ ]]; then
op='=~'
expect=${expect##\~}
fi
assert "$actual" "$op" "$expect" "system df[$i].${fields[0]}"
done
done < <(parse_table "$tests")
# Clean up
run_podman rm -f -t 0 $cname_stopped $cname_running
}
@test "podman system df - with active containers and volumes" {
c1=c1-$(safename)
c2=c2-$(safename)
run_podman run -v /myvol1 --name $c1 $IMAGE true
run_podman run -d -v /myvol2 --name $c2 $IMAGE top
run_podman system df --format '{{ .Type }}:{{ .Total }}:{{ .Active }}'
is "${lines[0]}" "Images:1:1" "system df : Images line"
is "${lines[1]}" "Containers:2:1" "system df : Containers line"
is "${lines[2]}" "Local Volumes:2:2" "system df : Volumes line"
# Try -v. (Grrr. No way to specify individual formats)
#
# Yes, I know this would be more elegant as a separate @test, but
# container/volume setup/teardown costs ~3 seconds and that matters.
run_podman system df -v
is "${lines[2]}" \
"${PODMAN_TEST_IMAGE_REGISTRY}/${PODMAN_TEST_IMAGE_USER}/${PODMAN_TEST_IMAGE_NAME} * ${PODMAN_TEST_IMAGE_TAG} [0-9a-f]* .* 2" \
"system df -v: the 'Images' line"
# Containers are listed in random order. Just check that each has 1 volume
is "${lines[5]}" \
"[0-9a-f]\{12\} *[0-9a-f]\{12\} .* 1 .* c[12]-$(safename)" \
"system df -v, 'Containers', first line"
is "${lines[6]}" \
"[0-9a-f]\{12\} *[0-9a-f]\{12\} .* 1 .* c[12]-$(safename)" \
"system df -v, 'Containers', second line"
# Volumes, likewise: random order.
is "${lines[9]}" "[0-9a-f]\{64\} *[01] * 0B" \
"system df -v, 'Volumes', first line"
is "${lines[10]}" "[0-9a-f]\{64\} *[01] * 0B" \
"system df -v, 'Volumes', second line"
# Make sure that the return image "raw" size is correct
run_podman image inspect $IMAGE --format "{{.Size}}"
expectedSize="$output"
run_podman system df --format "{{.RawSize}}"
is "${lines[0]}" "$expectedSize" "raw image size is correct"
# Clean up and check reclaimable image data
run_podman system df --format '{{.Reclaimable}}'
is "${lines[0]}" "0B (0%)" "cannot reclaim image data as it's still used by the containers"
run_podman stop $c2
# Create a second image by committing a container.
run_podman container commit -q $c1
image="$output"
run_podman system df --format '{{.Reclaimable}}'
is "${lines[0]}" ".* (100%)" "100 percent of image data is reclaimable because $IMAGE has unique size of 0"
# Make sure the unique size is now really 0. We cannot use --format for
# that unfortunately but we can exploit the fact that $IMAGE is used by
# two containers.
run_podman system df -v
is "$output" ".*0B\\s\\+2.*"
run_podman rm $c1 $c2
run_podman system df --format '{{.Reclaimable}}'
is "${lines[0]}" ".* (100%)" "100 percent of image data is reclaimable because all containers are gone"
run_podman rmi $image
run_podman volume rm -a
}
# vim: filetype=sh
|
