]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - cmd/safcm-remote/ainsl/ainsl_test.go
8e9b0c121a268747d2a234dab0e1a045927fd55f
[safcm/safcm.git] / cmd / safcm-remote / ainsl / ainsl_test.go
1 // Copyright (C) 2021  Simon Ruderich
2 //
3 // This program is free software: you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation, either version 3 of the License, or
6 // (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
16 package ainsl
17
18 import (
19         "fmt"
20         "io/fs"
21         "os"
22         "path/filepath"
23         "runtime"
24         "syscall"
25         "testing"
26
27         ft "ruderich.org/simon/safcm/cmd/safcm-remote/sync/filetest"
28         "ruderich.org/simon/safcm/testutil"
29 )
30
31 func TestHandle(t *testing.T) {
32         cwd, err := os.Getwd()
33         if err != nil {
34                 t.Fatal(err)
35         }
36         defer os.Chdir(cwd)
37
38         err = os.RemoveAll("testdata")
39         if err != nil {
40                 t.Fatal(err)
41         }
42         err = os.Mkdir("testdata", 0700)
43         if err != nil {
44                 t.Fatal(err)
45         }
46
47         // Set umask to test mode for new files
48         umask := syscall.Umask(027)
49         defer syscall.Umask(umask)
50
51         root := ft.File{
52                 Path: ".",
53                 Mode: fs.ModeDir | 0700,
54         }
55         _, uid, _, gid := ft.CurrentUserAndGroup()
56
57         symlinkExists := "open file: too many levels of symbolic links"
58         if runtime.GOOS == "freebsd" {
59                 // EMLINK instead of ELOOP
60                 symlinkExists = "open file: too many links"
61         }
62
63         tests := []struct {
64                 name       string
65                 path       string
66                 line       string
67                 create     bool
68                 prepare    func()
69                 expFiles   []ft.File
70                 expChanges []string
71                 expErr     error
72         }{
73
74                 // TODO: Add tests for chown and run them only as root
75
76                 {
77                         "missing",
78                         "file",
79                         "line",
80                         false,
81                         nil,
82                         []ft.File{
83                                 root,
84                         },
85                         nil,
86                         fmt.Errorf("\"file\": file does not exist, use -create"),
87                 },
88
89                 {
90                         "missing: create",
91                         "file",
92                         "line",
93                         true,
94                         nil,
95                         []ft.File{
96                                 root,
97                                 ft.File{
98                                         Path: "file",
99                                         Mode: 0640,
100                                         Data: []byte("line\n"),
101                                 },
102                         },
103                         []string{
104                                 fmt.Sprintf(`"file": created file (%d/%d -rw-r-----)`, uid, gid),
105                                 `"file": added line "line"`,
106                         },
107                         nil,
108                 },
109                 {
110                         "missing: create (empty line)",
111                         "file",
112                         "",
113                         true,
114                         nil,
115                         []ft.File{
116                                 root,
117                         },
118                         nil,
119                         fmt.Errorf("empty line"),
120                 },
121                 {
122                         "missing: create (newline)",
123                         "file",
124                         "line\n",
125                         true,
126                         nil,
127                         []ft.File{
128                                 root,
129                         },
130                         nil,
131                         fmt.Errorf("line must not contain newlines: \"line\\n\""),
132                 },
133
134                 {
135                         "exists: unchanged",
136                         "file",
137                         "line",
138                         true,
139                         func() {
140                                 ft.CreateFile("file", "line\n", 0641)
141                         },
142                         []ft.File{
143                                 root,
144                                 ft.File{
145                                         Path: "file",
146                                         Mode: 0641,
147                                         Data: []byte("line\n"),
148                                 },
149                         },
150                         nil,
151                         nil,
152                 },
153
154                 {
155                         "exists: append",
156                         "file",
157                         "line",
158                         true,
159                         func() {
160                                 ft.CreateFile("file", "existing\n", 0641)
161                         },
162                         []ft.File{
163                                 root,
164                                 ft.File{
165                                         Path: "file",
166                                         Mode: 0641,
167                                         Data: []byte("existing\nline\n"),
168                                 },
169                         },
170                         []string{
171                                 `"file": added line "line"`,
172                         },
173                         nil,
174                 },
175                 {
176                         "exists: append (no newline in file)",
177                         "file",
178                         "line",
179                         true,
180                         func() {
181                                 ft.CreateFile("file", "existing", 0641)
182                         },
183                         []ft.File{
184                                 root,
185                                 ft.File{
186                                         Path: "file",
187                                         Mode: 0641,
188                                         Data: []byte("existing\nline\n"),
189                                 },
190                         },
191                         []string{
192                                 `"file": added missing trailing newline`,
193                                 `"file": added line "line"`,
194                         },
195                         nil,
196                 },
197                 {
198                         "exists: append (only trailing newline I)",
199                         "file",
200                         "line",
201                         true,
202                         func() {
203                                 ft.CreateFile("file", "first\nline", 0641)
204                         },
205                         []ft.File{
206                                 root,
207                                 ft.File{
208                                         Path: "file",
209                                         Mode: 0641,
210                                         Data: []byte("first\nline\n"),
211                                 },
212                         },
213                         []string{
214                                 `"file": added missing trailing newline`,
215                         },
216                         nil,
217                 },
218                 {
219                         "exists: append (only trailing newline II)",
220                         "file",
221                         "first",
222                         true,
223                         func() {
224                                 ft.CreateFile("file", "first\nline", 0641)
225                         },
226                         []ft.File{
227                                 root,
228                                 ft.File{
229                                         Path: "file",
230                                         Mode: 0641,
231                                         Data: []byte("first\nline\n"),
232                                 },
233                         },
234                         []string{
235                                 `"file": added missing trailing newline`,
236                         },
237                         nil,
238                 },
239                 {
240                         "exists: append (partial line)",
241                         "file",
242                         "line with spaces",
243                         true,
244                         func() {
245                                 ft.CreateFile("file", "# line with spaces\n", 0641)
246                         },
247                         []ft.File{
248                                 root,
249                                 ft.File{
250                                         Path: "file",
251                                         Mode: 0641,
252                                         Data: []byte("# line with spaces\nline with spaces\n"),
253                                 },
254                         },
255                         []string{
256                                 `"file": added line "line with spaces"`,
257                         },
258                         nil,
259                 },
260
261                 {
262                         "exists: symlink",
263                         "file",
264                         "line",
265                         true,
266                         func() {
267                                 ft.CreateSymlink("file", "target")
268                         },
269                         []ft.File{
270                                 root,
271                                 ft.File{
272                                         Path: "file",
273                                         Mode: fs.ModeSymlink | 0777,
274                                         Data: []byte("target"),
275                                 },
276                         },
277                         nil,
278                         fmt.Errorf(symlinkExists),
279                 },
280                 {
281                         "exists: fifo",
282                         "file",
283                         "line",
284                         true,
285                         func() {
286                                 ft.CreateFifo("file", 0640)
287                         },
288                         []ft.File{
289                                 root,
290                                 ft.File{
291                                         Path: "file",
292                                         Mode: fs.ModeNamedPipe | 0640,
293                                 },
294                         },
295                         nil,
296                         fmt.Errorf("\"file\" is not a regular file but p---------"),
297                 },
298         }
299
300         for _, tc := range tests {
301                 t.Run(tc.name, func(t *testing.T) {
302                         // Create separate test directory for each test case
303                         path := filepath.Join(cwd, "testdata", tc.name)
304                         err = os.Mkdir(path, 0700)
305                         if err != nil {
306                                 t.Fatal(err)
307                         }
308                         err = os.Chdir(path)
309                         if err != nil {
310                                 t.Fatal(err)
311                         }
312
313                         if tc.prepare != nil {
314                                 tc.prepare()
315                         }
316
317                         changes, err := handle(tc.path, tc.line, tc.create)
318                         testutil.AssertEqual(t, "changes",
319                                 changes, tc.expChanges)
320                         testutil.AssertErrorEqual(t, "err", err, tc.expErr)
321
322                         files, err := ft.WalkDir(path)
323                         if err != nil {
324                                 t.Fatal(err)
325                         }
326                         testutil.AssertEqual(t, "files", files, tc.expFiles)
327                 })
328         }
329
330         if !t.Failed() {
331                 err = os.RemoveAll(filepath.Join(cwd, "testdata"))
332                 if err != nil {
333                         t.Fatal(err)
334                 }
335         }
336 }