talos

1
// This Source Code Form is subject to the terms of the Mozilla Public
2
// License, v. 2.0. If a copy of the MPL was not distributed with this
3
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4

5
package archiver_test
6

7
import (
8
	"context"
9
	"os"
10
	"path/filepath"
11
	"strconv"
12
	"testing"
13

14
	"github.com/stretchr/testify/suite"
15

16
	"github.com/siderolabs/talos/pkg/archiver"
17
)
18

19
type WalkerSuite struct {
20
	CommonSuite
21
}
22

23
func (suite *WalkerSuite) TestIterationDir() {
24
	ch, err := archiver.Walker(context.Background(), suite.tmpDir, archiver.WithSkipRoot())
25
	suite.Require().NoError(err)
26

27
	relPaths := []string(nil)
28

29
	for fi := range ch {
30
		suite.Require().NoError(fi.Error)
31
		relPaths = append(relPaths, fi.RelPath)
32

33
		if fi.RelPath == "usr/bin/mv" {
34
			suite.Assert().Equal("/usr/bin/cp", fi.Link)
35
		}
36
	}
37

38
	suite.Assert().Equal([]string{
39
		"dev", "dev/random",
40
		"etc", "etc/certs", "etc/certs/ca.crt", "etc/hostname",
41
		"lib", "lib/dynalib.so",
42
		"usr", "usr/bin", "usr/bin/cp", "usr/bin/mv",
43
	},
44
		relPaths)
45
}
46

47
func (suite *WalkerSuite) TestIterationFilter() {
48
	ch, err := archiver.Walker(context.Background(), suite.tmpDir, archiver.WithSkipRoot(), archiver.WithFnmatchPatterns("dev/*", "lib"))
49
	suite.Require().NoError(err)
50

51
	relPaths := []string(nil)
52

53
	for fi := range ch {
54
		suite.Require().NoError(fi.Error)
55
		relPaths = append(relPaths, fi.RelPath)
56

57
		if fi.RelPath == "usr/bin/mv" {
58
			suite.Assert().Equal("/usr/bin/cp", fi.Link)
59
		}
60
	}
61

62
	suite.Assert().Equal([]string{
63
		"dev/random",
64
		"lib",
65
	},
66
		relPaths)
67
}
68

69
func (suite *WalkerSuite) TestIterationMaxRecurseDepth() {
70
	for _, test := range []struct {
71
		maxDepth int
72
		result   []string
73
	}{
74
		{
75
			maxDepth: -1,
76
			result:   []string{".", "dev", "dev/random", "etc", "etc/certs", "etc/certs/ca.crt", "etc/hostname", "lib", "lib/dynalib.so", "usr", "usr/bin", "usr/bin/cp", "usr/bin/mv"},
77
		},
78
		{
79
			// confusing case
80
			maxDepth: 0,
81
			result:   []string{".", "dev", "etc", "lib", "usr"},
82
		},
83
		{
84
			maxDepth: 1,
85
			result:   []string{".", "dev", "etc", "lib", "usr"},
86
		},
87
		{
88
			maxDepth: 2,
89
			result:   []string{".", "dev", "dev/random", "etc", "etc/certs", "etc/hostname", "lib", "lib/dynalib.so", "usr", "usr/bin"},
90
		},
91
		{
92
			maxDepth: 3,
93
			result:   []string{".", "dev", "dev/random", "etc", "etc/certs", "etc/certs/ca.crt", "etc/hostname", "lib", "lib/dynalib.so", "usr", "usr/bin", "usr/bin/cp", "usr/bin/mv"},
94
		},
95
		{
96
			maxDepth: 4,
97
			result:   []string{".", "dev", "dev/random", "etc", "etc/certs", "etc/certs/ca.crt", "etc/hostname", "lib", "lib/dynalib.so", "usr", "usr/bin", "usr/bin/cp", "usr/bin/mv"},
98
		},
99
	} {
100
		suite.Run(strconv.Itoa(test.maxDepth), func() {
101
			suite.T().Parallel()
102

103
			ch, err := archiver.Walker(context.Background(), suite.tmpDir, archiver.WithMaxRecurseDepth(test.maxDepth))
104
			suite.Require().NoError(err)
105

106
			var result []string
107

108
			for fi := range ch {
109
				suite.Require().NoError(fi.Error)
110
				result = append(result, fi.RelPath)
111
			}
112

113
			suite.Equal(test.result, result)
114
		})
115
	}
116
}
117

118
func (suite *WalkerSuite) TestIterationFile() {
119
	ch, err := archiver.Walker(context.Background(), filepath.Join(suite.tmpDir, "usr/bin/cp"))
120
	suite.Require().NoError(err)
121

122
	relPaths := []string(nil)
123

124
	for fi := range ch {
125
		suite.Require().NoError(fi.Error)
126
		relPaths = append(relPaths, fi.RelPath)
127
	}
128

129
	suite.Assert().Equal([]string{"cp"},
130
		relPaths)
131
}
132

133
func (suite *WalkerSuite) TestIterationSymlink() {
134
	original := filepath.Join(suite.tmpDir, "original")
135
	err := os.Mkdir(original, 0o755)
136
	suite.Require().NoError(err)
137

138
	defer func() {
139
		err = os.RemoveAll(original)
140
		suite.Require().NoError(err)
141
	}()
142

143
	// NB: We make this a relative symlink to make the test more complete.
144
	newname := filepath.Join(suite.tmpDir, "new")
145
	err = os.Symlink("original", newname)
146
	suite.Require().NoError(err)
147

148
	defer func() {
149
		err = os.Remove(newname)
150
		suite.Require().NoError(err)
151
	}()
152

153
	err = os.WriteFile(filepath.Join(original, "original.txt"), []byte{}, 0o666)
154
	suite.Require().NoError(err)
155

156
	ch, err := archiver.Walker(context.Background(), newname)
157
	suite.Require().NoError(err)
158

159
	relPaths := []string(nil)
160

161
	for fi := range ch {
162
		suite.Require().NoError(fi.Error)
163
		relPaths = append(relPaths, fi.RelPath)
164
	}
165

166
	suite.Assert().Equal([]string{".", "original.txt"}, relPaths)
167
}
168

169
func (suite *WalkerSuite) TestIterationNotFound() {
170
	_, err := archiver.Walker(context.Background(), filepath.Join(suite.tmpDir, "doesntlivehere"))
171
	suite.Require().Error(err)
172
}
173

174
func (suite *WalkerSuite) TestIterationTypes() {
175
	ch, err := archiver.Walker(context.Background(), suite.tmpDir, archiver.WithFileTypes(archiver.DirectoryFileType))
176
	suite.Require().NoError(err)
177

178
	relPaths := []string(nil)
179

180
	for fi := range ch {
181
		suite.Require().NoError(fi.Error)
182
		relPaths = append(relPaths, fi.RelPath)
183
	}
184

185
	suite.Assert().Equal([]string{
186
		".", "dev", "etc", "etc/certs", "lib", "usr", "usr/bin",
187
	},
188
		relPaths)
189
}
190

191
func TestWalkerSuite(t *testing.T) {
192
	suite.Run(t, new(WalkerSuite))
193
}
194