]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - cmd/safcm-remote/ainsl/ainsl_test.go
tests: go fmt and rewrap
[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         "reflect"
24         "syscall"
25         "testing"
26
27         "github.com/google/go-cmp/cmp"
28
29         ft "ruderich.org/simon/safcm/cmd/safcm-remote/sync/filetest"
30 )
31
32 func TestHandle(t *testing.T) {
33         cwd, err := os.Getwd()
34         if err != nil {
35                 t.Fatal(err)
36         }
37         defer os.Chdir(cwd)
38
39         err = os.RemoveAll("testdata")
40         if err != nil {
41                 t.Fatal(err)
42         }
43         err = os.Mkdir("testdata", 0700)
44         if err != nil {
45                 t.Fatal(err)
46         }
47
48         // Set umask to test mode for new files
49         umask := syscall.Umask(027)
50         defer syscall.Umask(umask)
51
52         root := ft.File{
53                 Path: ".",
54                 Mode: fs.ModeDir | 0700,
55         }
56         _, uid, _, gid := ft.CurrentUserAndGroup()
57
58         tests := []struct {
59                 name       string
60                 path       string
61                 line       string
62                 create     bool
63                 prepare    func()
64                 expFiles   []ft.File
65                 expChanges []string
66                 expErr     error
67         }{
68
69                 // TODO: Add tests for chown and run them only as root
70
71                 {
72                         "missing",
73                         "file",
74                         "line",
75                         false,
76                         nil,
77                         []ft.File{
78                                 root,
79                         },
80                         nil,
81                         fmt.Errorf("\"file\": file does not exist, use -create"),
82                 },
83
84                 {
85                         "missing: create",
86                         "file",
87                         "line",
88                         true,
89                         nil,
90                         []ft.File{
91                                 root,
92                                 ft.File{
93                                         Path: "file",
94                                         Mode: 0640,
95                                         Data: []byte("line\n"),
96                                 },
97                         },
98                         []string{
99                                 fmt.Sprintf(`"file": created file (%d/%d -rw-r-----)`, uid, gid),
100                                 `"file": added line "line"`,
101                         },
102                         nil,
103                 },
104                 {
105                         "missing: create (empty line)",
106                         "file",
107                         "",
108                         true,
109                         nil,
110                         []ft.File{
111                                 root,
112                         },
113                         nil,
114                         fmt.Errorf("empty line"),
115                 },
116                 {
117                         "missing: create (newline)",
118                         "file",
119                         "line\n",
120                         true,
121                         nil,
122                         []ft.File{
123                                 root,
124                         },
125                         nil,
126                         fmt.Errorf("line must not contain newlines: \"line\\n\""),
127                 },
128
129                 {
130                         "exists: unchanged",
131                         "file",
132                         "line",
133                         true,
134                         func() {
135                                 ft.CreateFile("file", "line\n", 0641)
136                         },
137                         []ft.File{
138                                 root,
139                                 ft.File{
140                                         Path: "file",
141                                         Mode: 0641,
142                                         Data: []byte("line\n"),
143                                 },
144                         },
145                         nil,
146                         nil,
147                 },
148
149                 {
150                         "exists: append",
151                         "file",
152                         "line",
153                         true,
154                         func() {
155                                 ft.CreateFile("file", "existing\n", 0641)
156                         },
157                         []ft.File{
158                                 root,
159                                 ft.File{
160                                         Path: "file",
161                                         Mode: 0641,
162                                         Data: []byte("existing\nline\n"),
163                                 },
164                         },
165                         []string{
166                                 `"file": added line "line"`,
167                         },
168                         nil,
169                 },
170                 {
171                         "exists: append (no newline in file)",
172                         "file",
173                         "line",
174                         true,
175                         func() {
176                                 ft.CreateFile("file", "existing", 0641)
177                         },
178                         []ft.File{
179                                 root,
180                                 ft.File{
181                                         Path: "file",
182                                         Mode: 0641,
183                                         Data: []byte("existing\nline\n"),
184                                 },
185                         },
186                         []string{
187                                 `"file": added missing trailing newline`,
188                                 `"file": added line "line"`,
189                         },
190                         nil,
191                 },
192                 {
193                         "exists: append (only trailing newline I)",
194                         "file",
195                         "line",
196                         true,
197                         func() {
198                                 ft.CreateFile("file", "first\nline", 0641)
199                         },
200                         []ft.File{
201                                 root,
202                                 ft.File{
203                                         Path: "file",
204                                         Mode: 0641,
205                                         Data: []byte("first\nline\n"),
206                                 },
207                         },
208                         []string{
209                                 `"file": added missing trailing newline`,
210                         },
211                         nil,
212                 },
213                 {
214                         "exists: append (only trailing newline II)",
215                         "file",
216                         "first",
217                         true,
218                         func() {
219                                 ft.CreateFile("file", "first\nline", 0641)
220                         },
221                         []ft.File{
222                                 root,
223                                 ft.File{
224                                         Path: "file",
225                                         Mode: 0641,
226                                         Data: []byte("first\nline\n"),
227                                 },
228                         },
229                         []string{
230                                 `"file": added missing trailing newline`,
231                         },
232                         nil,
233                 },
234                 {
235                         "exists: append (partial line)",
236                         "file",
237                         "line with spaces",
238                         true,
239                         func() {
240                                 ft.CreateFile("file", "# line with spaces\n", 0641)
241                         },
242                         []ft.File{
243                                 root,
244                                 ft.File{
245                                         Path: "file",
246                                         Mode: 0641,
247                                         Data: []byte("# line with spaces\nline with spaces\n"),
248                                 },
249                         },
250                         []string{
251                                 `"file": added line "line with spaces"`,
252                         },
253                         nil,
254                 },
255
256                 {
257                         "exists: symlink",
258                         "file",
259                         "line",
260                         true,
261                         func() {
262                                 ft.CreateSymlink("file", "target")
263                         },
264                         []ft.File{
265                                 root,
266                                 ft.File{
267                                         Path: "file",
268                                         Mode: fs.ModeSymlink | 0777,
269                                         Data: []byte("target"),
270                                 },
271                         },
272                         nil,
273                         fmt.Errorf("open file: too many levels of symbolic links"),
274                 },
275                 {
276                         "exists: fifo",
277                         "file",
278                         "line",
279                         true,
280                         func() {
281                                 ft.CreateFifo("file", 0640)
282                         },
283                         []ft.File{
284                                 root,
285                                 ft.File{
286                                         Path: "file",
287                                         Mode: fs.ModeNamedPipe | 0640,
288                                 },
289                         },
290                         nil,
291                         fmt.Errorf("\"file\" is not a regular file but p---------"),
292                 },
293         }
294
295         for _, tc := range tests {
296                 t.Run(tc.name, func(t *testing.T) {
297                         // Create separate test directory for each test case
298                         path := filepath.Join(cwd, "testdata", tc.name)
299                         err = os.Mkdir(path, 0700)
300                         if err != nil {
301                                 t.Fatal(err)
302                         }
303                         err = os.Chdir(path)
304                         if err != nil {
305                                 t.Fatal(err)
306                         }
307
308                         if tc.prepare != nil {
309                                 tc.prepare()
310                         }
311
312                         changes, err := handle(tc.path, tc.line, tc.create)
313                         if !reflect.DeepEqual(tc.expChanges, changes) {
314                                 t.Errorf("changes: %s",
315                                         cmp.Diff(tc.expChanges, changes))
316                         }
317                         // Ugly but the simplest way to compare errors (including nil)
318                         if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", tc.expErr) {
319                                 t.Errorf("err = %#v, want %#v",
320                                         err, tc.expErr)
321                         }
322
323                         files, err := ft.WalkDir(path)
324                         if err != nil {
325                                 t.Fatal(err)
326                         }
327                         if !reflect.DeepEqual(tc.expFiles, files) {
328                                 t.Errorf("files: %s",
329                                         cmp.Diff(tc.expFiles, files))
330                         }
331                 })
332         }
333
334         if !t.Failed() {
335                 err = os.RemoveAll(filepath.Join(cwd, "testdata"))
336                 if err != nil {
337                         t.Fatal(err)
338                 }
339         }
340 }