]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - cmd/safcm-remote/sync/files_test.go
tests: go fmt and rewrap
[safcm/safcm.git] / cmd / safcm-remote / sync / files_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 sync
17
18 import (
19         "fmt"
20         "io/fs"
21         "math/rand"
22         "os"
23         "path/filepath"
24         "reflect"
25         "regexp"
26         "testing"
27
28         "github.com/google/go-cmp/cmp"
29
30         "ruderich.org/simon/safcm"
31         ft "ruderich.org/simon/safcm/cmd/safcm-remote/sync/filetest"
32 )
33
34 var randFilesRegexp = regexp.MustCompile(`\d+"$`)
35
36 func TestSyncFiles(t *testing.T) {
37         cwd, err := os.Getwd()
38         if err != nil {
39                 t.Fatal(err)
40         }
41         defer os.Chdir(cwd)
42
43         err = os.RemoveAll("testdata")
44         if err != nil {
45                 t.Fatal(err)
46         }
47         err = os.Mkdir("testdata", 0700)
48         if err != nil {
49                 t.Fatal(err)
50         }
51
52         root := ft.File{
53                 Path: ".",
54                 Mode: fs.ModeDir | 0700,
55         }
56         user, uid, group, gid := ft.CurrentUserAndGroup()
57
58         tmpTestFilePath := "/tmp/safcm-sync-files-test-file"
59
60         tests := []struct {
61                 name     string
62                 req      safcm.MsgSyncReq
63                 prepare  func()
64                 triggers []string
65                 expFiles []ft.File
66                 expResp  safcm.MsgSyncResp
67                 expDbg   []string
68                 expErr   error
69         }{
70
71                 // NOTE: Also update MsgSyncResp in safcm test cases when
72                 // changing anything here!
73
74                 // See TestSyncFile() for most file related tests. This
75                 // function only tests the overall results and triggers.
76
77                 {
78                         "basic: create",
79                         safcm.MsgSyncReq{
80                                 Files: map[string]*safcm.File{
81                                         ".": {
82                                                 Path:      ".",
83                                                 Mode:      fs.ModeDir | 0700,
84                                                 Uid:       -1,
85                                                 Gid:       -1,
86                                                 OrigGroup: "group",
87                                         },
88                                         "dir": {
89                                                 Path:      "dir",
90                                                 Mode:      fs.ModeDir | 0755,
91                                                 Uid:       -1,
92                                                 Gid:       -1,
93                                                 OrigGroup: "group",
94                                         },
95                                         "dir/file": {
96                                                 Path:      "dir/file",
97                                                 Mode:      0644,
98                                                 Uid:       -1,
99                                                 Gid:       -1,
100                                                 Data:      []byte("content\n"),
101                                                 OrigGroup: "group",
102                                         },
103                                 },
104                         },
105                         nil,
106                         nil,
107                         []ft.File{
108                                 root,
109                                 {
110                                         Path: "dir",
111                                         Mode: fs.ModeDir | 0755,
112                                 },
113                                 {
114                                         Path: "dir/file",
115                                         Mode: 0644,
116                                         Data: []byte("content\n"),
117                                 },
118                         },
119                         safcm.MsgSyncResp{
120                                 FileChanges: []safcm.FileChange{
121                                         {
122                                                 Path:    "dir",
123                                                 Created: true,
124                                                 New: safcm.FileChangeInfo{
125                                                         Mode:  fs.ModeDir | 0755,
126                                                         User:  user,
127                                                         Uid:   uid,
128                                                         Group: group,
129                                                         Gid:   gid,
130                                                 },
131                                         },
132                                         {
133                                                 Path:    "dir/file",
134                                                 Created: true,
135                                                 New: safcm.FileChangeInfo{
136                                                         Mode:  0644,
137                                                         User:  user,
138                                                         Uid:   uid,
139                                                         Group: group,
140                                                         Gid:   gid,
141                                                 },
142                                         },
143                                 },
144                         },
145                         []string{
146                                 `4: sync remote: files: "." (group): unchanged`,
147                                 `4: sync remote: files: "dir" (group): will create`,
148                                 `3: sync remote: files: "dir" (group): creating`,
149                                 `4: sync remote: files: "dir" (group): creating directory`,
150                                 `4: sync remote: files: "dir" (group): chmodding drwxr-xr-x`,
151                                 fmt.Sprintf(`4: sync remote: files: "dir" (group): chowning %d/%d`, uid, gid),
152                                 `4: sync remote: files: "dir/file" (group): will create`,
153                                 `3: sync remote: files: "dir/file" (group): creating`,
154                                 `4: sync remote: files: "dir/file" (group): creating temporary file "dir/.file*"`,
155                                 `4: sync remote: files: "dir/file" (group): renaming "dir/.fileRND"`,
156                         },
157                         nil,
158                 },
159
160                 {
161                         "basic: no change",
162                         safcm.MsgSyncReq{
163                                 Files: map[string]*safcm.File{
164                                         ".": {
165                                                 Path:      ".",
166                                                 Mode:      fs.ModeDir | 0700,
167                                                 Uid:       -1,
168                                                 Gid:       -1,
169                                                 OrigGroup: "group",
170                                         },
171                                         "dir": {
172                                                 Path:      "dir",
173                                                 Mode:      fs.ModeDir | 0755,
174                                                 Uid:       -1,
175                                                 Gid:       -1,
176                                                 OrigGroup: "group",
177                                         },
178                                         "dir/file": {
179                                                 Path:      "dir/file",
180                                                 Mode:      0644,
181                                                 Uid:       -1,
182                                                 Gid:       -1,
183                                                 Data:      []byte("content\n"),
184                                                 OrigGroup: "group",
185                                         },
186                                 },
187                         },
188                         func() {
189                                 ft.CreateDirectory("dir", 0755)
190                                 ft.CreateFile("dir/file", "content\n", 0644)
191                         },
192                         nil,
193                         []ft.File{
194                                 root,
195                                 {
196                                         Path: "dir",
197                                         Mode: fs.ModeDir | 0755,
198                                 },
199                                 {
200                                         Path: "dir/file",
201                                         Mode: 0644,
202                                         Data: []byte("content\n"),
203                                 },
204                         },
205                         safcm.MsgSyncResp{},
206                         []string{
207                                 `4: sync remote: files: "." (group): unchanged`,
208                                 `4: sync remote: files: "dir" (group): unchanged`,
209                                 `4: sync remote: files: "dir/file" (group): unchanged`,
210                         },
211                         nil,
212                 },
213
214                 {
215                         "invalid File: user",
216                         safcm.MsgSyncReq{
217                                 Files: map[string]*safcm.File{
218                                         ".": {
219                                                 Path:      ".",
220                                                 Mode:      fs.ModeDir | 0700,
221                                                 User:      "user",
222                                                 Uid:       1,
223                                                 Gid:       -1,
224                                                 OrigGroup: "group",
225                                         },
226                                 },
227                         },
228                         nil,
229                         nil,
230                         []ft.File{
231                                 root,
232                         },
233                         safcm.MsgSyncResp{},
234                         nil,
235                         fmt.Errorf("\".\": cannot set both User (\"user\") and Uid (1)"),
236                 },
237                 {
238                         "invalid File: group",
239                         safcm.MsgSyncReq{
240                                 Files: map[string]*safcm.File{
241                                         ".": {
242                                                 Path:      ".",
243                                                 Mode:      fs.ModeDir | 0700,
244                                                 Uid:       -1,
245                                                 Group:     "group",
246                                                 Gid:       1,
247                                                 OrigGroup: "group",
248                                         },
249                                 },
250                         },
251                         nil,
252                         nil,
253                         []ft.File{
254                                 root,
255                         },
256                         safcm.MsgSyncResp{},
257                         nil,
258                         fmt.Errorf("\".\": cannot set both Group (\"group\") and Gid (1)"),
259                 },
260
261                 {
262                         // We use relative paths for most tests because we
263                         // don't want to modify the running system. Use this
264                         // test (and the one below for triggers) as a basic
265                         // check that absolute paths work.
266                         "absolute paths: no change",
267                         safcm.MsgSyncReq{
268                                 Files: map[string]*safcm.File{
269                                         "/": {
270                                                 Path:      "/",
271                                                 Mode:      fs.ModeDir | 0755,
272                                                 User:      "root",
273                                                 Uid:       -1,
274                                                 Group:     "root",
275                                                 Gid:       -1,
276                                                 OrigGroup: "group",
277                                         },
278                                         "/etc": {
279                                                 Path:      "/etc",
280                                                 Mode:      fs.ModeDir | 0755,
281                                                 User:      "root",
282                                                 Uid:       -1,
283                                                 Group:     "root",
284                                                 Gid:       -1,
285                                                 OrigGroup: "group",
286                                         },
287                                         "/tmp": {
288                                                 Path:      "/tmp",
289                                                 Mode:      fs.ModeDir | 0777 | fs.ModeSticky,
290                                                 User:      "root",
291                                                 Uid:       -1,
292                                                 Group:     "root",
293                                                 Gid:       -1,
294                                                 OrigGroup: "group",
295                                         },
296                                         "/var/tmp": {
297                                                 Path:      "/var/tmp",
298                                                 Mode:      fs.ModeDir | 0777 | fs.ModeSticky,
299                                                 User:      "root",
300                                                 Uid:       -1,
301                                                 Group:     "root",
302                                                 Gid:       -1,
303                                                 OrigGroup: "group",
304                                         },
305                                 },
306                         },
307                         nil,
308                         nil,
309                         []ft.File{
310                                 root,
311                         },
312                         safcm.MsgSyncResp{},
313                         []string{
314                                 `4: sync remote: files: "/" (group): unchanged`,
315                                 `4: sync remote: files: "/etc" (group): unchanged`,
316                                 `4: sync remote: files: "/tmp" (group): unchanged`,
317                                 `4: sync remote: files: "/var/tmp" (group): unchanged`,
318                         },
319                         nil,
320                 },
321
322                 {
323                         "triggers: no change",
324                         safcm.MsgSyncReq{
325                                 Files: map[string]*safcm.File{
326                                         ".": {
327                                                 Path:      ".",
328                                                 Mode:      fs.ModeDir | 0700,
329                                                 Uid:       -1,
330                                                 Gid:       -1,
331                                                 OrigGroup: "group",
332                                                 TriggerCommands: []string{
333                                                         "echo trigger .",
334                                                 },
335                                         },
336                                         "dir": {
337                                                 Path:      "dir",
338                                                 Mode:      fs.ModeDir | 0755,
339                                                 Uid:       -1,
340                                                 Gid:       -1,
341                                                 OrigGroup: "group",
342                                                 TriggerCommands: []string{
343                                                         "echo trigger dir",
344                                                 },
345                                         },
346                                         "dir/file": {
347                                                 Path:      "dir/file",
348                                                 Mode:      0644,
349                                                 Uid:       -1,
350                                                 Gid:       -1,
351                                                 Data:      []byte("content\n"),
352                                                 OrigGroup: "group",
353                                                 TriggerCommands: []string{
354                                                         "echo trigger dir/file",
355                                                 },
356                                         },
357                                 },
358                         },
359                         func() {
360                                 ft.CreateDirectory("dir", 0755)
361                                 ft.CreateFile("dir/file", "content\n", 0644)
362                         },
363                         nil,
364                         []ft.File{
365                                 root,
366                                 {
367                                         Path: "dir",
368                                         Mode: fs.ModeDir | 0755,
369                                 },
370                                 {
371                                         Path: "dir/file",
372                                         Mode: 0644,
373                                         Data: []byte("content\n"),
374                                 },
375                         },
376                         safcm.MsgSyncResp{},
377                         []string{
378                                 `4: sync remote: files: "." (group): unchanged`,
379                                 `4: sync remote: files: "dir" (group): unchanged`,
380                                 `4: sync remote: files: "dir/file" (group): unchanged`,
381                         },
382                         nil,
383                 },
384
385                 {
386                         "triggers: change root",
387                         safcm.MsgSyncReq{
388                                 Files: map[string]*safcm.File{
389                                         ".": {
390                                                 Path:      ".",
391                                                 Mode:      fs.ModeDir | 0700,
392                                                 Uid:       -1,
393                                                 Gid:       -1,
394                                                 OrigGroup: "group",
395                                                 TriggerCommands: []string{
396                                                         "echo trigger .",
397                                                 },
398                                         },
399                                         "dir": {
400                                                 Path:      "dir",
401                                                 Mode:      fs.ModeDir | 0755,
402                                                 Uid:       -1,
403                                                 Gid:       -1,
404                                                 OrigGroup: "group",
405                                                 TriggerCommands: []string{
406                                                         "echo trigger dir",
407                                                 },
408                                         },
409                                         "dir/file": {
410                                                 Path:      "dir/file",
411                                                 Mode:      0644,
412                                                 Uid:       -1,
413                                                 Gid:       -1,
414                                                 Data:      []byte("content\n"),
415                                                 OrigGroup: "group",
416                                                 TriggerCommands: []string{
417                                                         "echo trigger dir/file",
418                                                 },
419                                         },
420                                 },
421                         },
422                         func() {
423                                 err = os.Chmod(".", 0750)
424                                 if err != nil {
425                                         panic(err)
426                                 }
427                                 ft.CreateDirectory("dir", 0755)
428                                 ft.CreateFile("dir/file", "content\n", 0644)
429                         },
430                         []string{
431                                 ".",
432                         },
433                         []ft.File{
434                                 root,
435                                 {
436                                         Path: "dir",
437                                         Mode: fs.ModeDir | 0755,
438                                 },
439                                 {
440                                         Path: "dir/file",
441                                         Mode: 0644,
442                                         Data: []byte("content\n"),
443                                 },
444                         },
445                         safcm.MsgSyncResp{
446                                 FileChanges: []safcm.FileChange{
447                                         {
448                                                 Path: ".",
449                                                 Old: safcm.FileChangeInfo{
450                                                         Mode:  fs.ModeDir | 0750,
451                                                         User:  user,
452                                                         Uid:   uid,
453                                                         Group: group,
454                                                         Gid:   gid,
455                                                 },
456                                                 New: safcm.FileChangeInfo{
457                                                         Mode:  fs.ModeDir | 0700,
458                                                         User:  user,
459                                                         Uid:   uid,
460                                                         Group: group,
461                                                         Gid:   gid,
462                                                 },
463                                         },
464                                 },
465                         },
466                         []string{
467                                 `4: sync remote: files: "." (group): permission differs drwxr-x--- -> drwx------`,
468                                 `3: sync remote: files: "." (group): updating`,
469                                 `4: sync remote: files: "." (group): chmodding drwx------`,
470                                 `3: sync remote: files: ".": queuing trigger on "."`,
471                                 `4: sync remote: files: "dir" (group): unchanged`,
472                                 `4: sync remote: files: "dir/file" (group): unchanged`,
473                         },
474                         nil,
475                 },
476
477                 {
478                         "triggers: change middle",
479                         safcm.MsgSyncReq{
480                                 Files: map[string]*safcm.File{
481                                         ".": {
482                                                 Path:      ".",
483                                                 Mode:      fs.ModeDir | 0700,
484                                                 Uid:       -1,
485                                                 Gid:       -1,
486                                                 OrigGroup: "group",
487                                                 TriggerCommands: []string{
488                                                         "echo trigger .",
489                                                 },
490                                         },
491                                         "dir": {
492                                                 Path:      "dir",
493                                                 Mode:      fs.ModeDir | 0755,
494                                                 Uid:       -1,
495                                                 Gid:       -1,
496                                                 OrigGroup: "group",
497                                                 TriggerCommands: []string{
498                                                         "echo trigger dir",
499                                                 },
500                                         },
501                                         "dir/file": {
502                                                 Path:      "dir/file",
503                                                 Mode:      0644,
504                                                 Uid:       -1,
505                                                 Gid:       -1,
506                                                 Data:      []byte("content\n"),
507                                                 OrigGroup: "group",
508                                                 TriggerCommands: []string{
509                                                         "echo trigger dir/file",
510                                                 },
511                                         },
512                                 },
513                         },
514                         func() {
515                                 ft.CreateDirectory("dir", 0750)
516                                 ft.CreateFile("dir/file", "content\n", 0644)
517                         },
518                         []string{
519                                 ".",
520                                 "dir",
521                         },
522                         []ft.File{
523                                 root,
524                                 {
525                                         Path: "dir",
526                                         Mode: fs.ModeDir | 0755,
527                                 },
528                                 {
529                                         Path: "dir/file",
530                                         Mode: 0644,
531                                         Data: []byte("content\n"),
532                                 },
533                         },
534                         safcm.MsgSyncResp{
535                                 FileChanges: []safcm.FileChange{
536                                         {
537                                                 Path: "dir",
538                                                 Old: safcm.FileChangeInfo{
539                                                         Mode:  fs.ModeDir | 0750,
540                                                         User:  user,
541                                                         Uid:   uid,
542                                                         Group: group,
543                                                         Gid:   gid,
544                                                 },
545                                                 New: safcm.FileChangeInfo{
546                                                         Mode:  fs.ModeDir | 0755,
547                                                         User:  user,
548                                                         Uid:   uid,
549                                                         Group: group,
550                                                         Gid:   gid,
551                                                 },
552                                         },
553                                 },
554                         },
555                         []string{
556                                 `4: sync remote: files: "." (group): unchanged`,
557                                 `4: sync remote: files: "dir" (group): permission differs drwxr-x--- -> drwxr-xr-x`,
558                                 `3: sync remote: files: "dir" (group): updating`,
559                                 `4: sync remote: files: "dir" (group): chmodding drwxr-xr-x`,
560                                 `3: sync remote: files: "dir": queuing trigger on "."`,
561                                 `3: sync remote: files: "dir": queuing trigger on "dir"`,
562                                 `4: sync remote: files: "dir/file" (group): unchanged`,
563                         },
564                         nil,
565                 },
566
567                 {
568                         "triggers: change leaf",
569                         safcm.MsgSyncReq{
570                                 Files: map[string]*safcm.File{
571                                         ".": {
572                                                 Path:      ".",
573                                                 Mode:      fs.ModeDir | 0700,
574                                                 Uid:       -1,
575                                                 Gid:       -1,
576                                                 OrigGroup: "group",
577                                                 TriggerCommands: []string{
578                                                         "echo trigger .",
579                                                 },
580                                         },
581                                         "dir": {
582                                                 Path:      "dir",
583                                                 Mode:      fs.ModeDir | 0755,
584                                                 Uid:       -1,
585                                                 Gid:       -1,
586                                                 OrigGroup: "group",
587                                                 TriggerCommands: []string{
588                                                         "echo trigger dir",
589                                                 },
590                                         },
591                                         "dir/file": {
592                                                 Path:      "dir/file",
593                                                 Mode:      0644,
594                                                 Uid:       -1,
595                                                 Gid:       -1,
596                                                 Data:      []byte("content\n"),
597                                                 OrigGroup: "group",
598                                                 TriggerCommands: []string{
599                                                         "echo trigger dir/file",
600                                                 },
601                                         },
602                                 },
603                         },
604                         func() {
605                                 ft.CreateDirectory("dir", 0755)
606                         },
607                         []string{
608                                 ".",
609                                 "dir",
610                                 "dir/file",
611                         },
612                         []ft.File{
613                                 root,
614                                 {
615                                         Path: "dir",
616                                         Mode: fs.ModeDir | 0755,
617                                 },
618                                 {
619                                         Path: "dir/file",
620                                         Mode: 0644,
621                                         Data: []byte("content\n"),
622                                 },
623                         },
624                         safcm.MsgSyncResp{
625                                 FileChanges: []safcm.FileChange{
626                                         {
627                                                 Path:    "dir/file",
628                                                 Created: true,
629                                                 New: safcm.FileChangeInfo{
630                                                         Mode:  0644,
631                                                         User:  user,
632                                                         Uid:   uid,
633                                                         Group: group,
634                                                         Gid:   gid,
635                                                 },
636                                         },
637                                 },
638                         },
639                         []string{
640                                 `4: sync remote: files: "." (group): unchanged`,
641                                 `4: sync remote: files: "dir" (group): unchanged`,
642                                 `4: sync remote: files: "dir/file" (group): will create`,
643                                 `3: sync remote: files: "dir/file" (group): creating`,
644                                 `4: sync remote: files: "dir/file" (group): creating temporary file "dir/.file*"`,
645                                 `4: sync remote: files: "dir/file" (group): renaming "dir/.fileRND"`,
646                                 `3: sync remote: files: "dir/file": queuing trigger on "."`,
647                                 `3: sync remote: files: "dir/file": queuing trigger on "dir"`,
648                                 `3: sync remote: files: "dir/file": queuing trigger on "dir/file"`,
649                         },
650                         nil,
651                 },
652
653                 {
654                         "triggers: multiple changes",
655                         safcm.MsgSyncReq{
656                                 Files: map[string]*safcm.File{
657                                         ".": {
658                                                 Path:      ".",
659                                                 Mode:      fs.ModeDir | 0700,
660                                                 Uid:       -1,
661                                                 Gid:       -1,
662                                                 OrigGroup: "group",
663                                                 TriggerCommands: []string{
664                                                         "echo trigger .",
665                                                 },
666                                         },
667                                         "dir": {
668                                                 Path:      "dir",
669                                                 Mode:      fs.ModeDir | 0755,
670                                                 Uid:       -1,
671                                                 Gid:       -1,
672                                                 OrigGroup: "group",
673                                                 TriggerCommands: []string{
674                                                         "echo trigger dir",
675                                                 },
676                                         },
677                                         "dir/file": {
678                                                 Path:      "dir/file",
679                                                 Mode:      0644,
680                                                 Uid:       -1,
681                                                 Gid:       -1,
682                                                 Data:      []byte("content\n"),
683                                                 OrigGroup: "group",
684                                                 TriggerCommands: []string{
685                                                         "echo trigger dir/file",
686                                                 },
687                                         },
688                                 },
689                         },
690                         nil,
691                         []string{
692                                 ".",
693                                 "dir",
694                                 "dir/file",
695                         },
696                         []ft.File{
697                                 root,
698                                 {
699                                         Path: "dir",
700                                         Mode: fs.ModeDir | 0755,
701                                 },
702                                 {
703                                         Path: "dir/file",
704                                         Mode: 0644,
705                                         Data: []byte("content\n"),
706                                 },
707                         },
708                         safcm.MsgSyncResp{
709                                 FileChanges: []safcm.FileChange{
710                                         {
711                                                 Path:    "dir",
712                                                 Created: true,
713                                                 New: safcm.FileChangeInfo{
714                                                         Mode:  fs.ModeDir | 0755,
715                                                         User:  user,
716                                                         Uid:   uid,
717                                                         Group: group,
718                                                         Gid:   gid,
719                                                 },
720                                         },
721                                         {
722                                                 Path:    "dir/file",
723                                                 Created: true,
724                                                 New: safcm.FileChangeInfo{
725                                                         Mode:  0644,
726                                                         User:  user,
727                                                         Uid:   uid,
728                                                         Group: group,
729                                                         Gid:   gid,
730                                                 },
731                                         },
732                                 },
733                         },
734                         []string{
735                                 `4: sync remote: files: "." (group): unchanged`,
736                                 `4: sync remote: files: "dir" (group): will create`,
737                                 `3: sync remote: files: "dir" (group): creating`,
738                                 `4: sync remote: files: "dir" (group): creating directory`,
739                                 `4: sync remote: files: "dir" (group): chmodding drwxr-xr-x`,
740                                 fmt.Sprintf(`4: sync remote: files: "dir" (group): chowning %d/%d`, uid, gid),
741                                 `3: sync remote: files: "dir": queuing trigger on "."`,
742                                 `3: sync remote: files: "dir": queuing trigger on "dir"`,
743                                 `4: sync remote: files: "dir/file" (group): will create`,
744                                 `3: sync remote: files: "dir/file" (group): creating`,
745                                 `4: sync remote: files: "dir/file" (group): creating temporary file "dir/.file*"`,
746                                 `4: sync remote: files: "dir/file" (group): renaming "dir/.fileRND"`,
747                                 `4: sync remote: files: "dir/file": skipping trigger on ".", already active`,
748                                 `4: sync remote: files: "dir/file": skipping trigger on "dir", already active`,
749                                 `3: sync remote: files: "dir/file": queuing trigger on "dir/file"`,
750                         },
751                         nil,
752                 },
753
754                 {
755                         "triggers: absolute paths",
756                         safcm.MsgSyncReq{
757                                 Files: map[string]*safcm.File{
758                                         "/": {
759                                                 Path:      "/",
760                                                 Mode:      fs.ModeDir | 0755,
761                                                 User:      "root",
762                                                 Uid:       -1,
763                                                 Group:     "root",
764                                                 Gid:       -1,
765                                                 OrigGroup: "group",
766                                                 TriggerCommands: []string{
767                                                         "echo trigger /",
768                                                 },
769                                         },
770                                         "/tmp": {
771                                                 Path:      "/tmp",
772                                                 Mode:      fs.ModeDir | 0777 | fs.ModeSticky,
773                                                 User:      "root",
774                                                 Uid:       -1,
775                                                 Group:     "root",
776                                                 Gid:       -1,
777                                                 OrigGroup: "group",
778                                                 TriggerCommands: []string{
779                                                         "echo trigger /tmp",
780                                                 },
781                                         },
782                                         tmpTestFilePath: {
783                                                 Path:      tmpTestFilePath,
784                                                 Mode:      0600,
785                                                 Uid:       -1,
786                                                 Gid:       -1,
787                                                 OrigGroup: "group",
788                                                 TriggerCommands: []string{
789                                                         "echo trigger /tmp/file",
790                                                 },
791                                         },
792                                 },
793                         },
794                         func() {
795                                 // This is slightly racy but the file name
796                                 // should be rare enough that this isn't an
797                                 // issue
798                                 _, err := os.Stat(tmpTestFilePath)
799                                 if err == nil {
800                                         t.Fatalf("%q exists, aborting",
801                                                 tmpTestFilePath)
802                                 }
803                         },
804                         []string{
805                                 "/",
806                                 "/tmp",
807                                 // Don't use variable for more robust test
808                                 "/tmp/safcm-sync-files-test-file",
809                         },
810                         []ft.File{
811                                 root,
812                         },
813                         safcm.MsgSyncResp{
814                                 FileChanges: []safcm.FileChange{
815                                         {
816                                                 Path:    "/tmp/safcm-sync-files-test-file",
817                                                 Created: true,
818                                                 New: safcm.FileChangeInfo{
819                                                         Mode:  0600,
820                                                         User:  user,
821                                                         Uid:   uid,
822                                                         Group: group,
823                                                         Gid:   gid,
824                                                 },
825                                         },
826                                 },
827                         },
828                         []string{
829                                 `4: sync remote: files: "/" (group): unchanged`,
830                                 `4: sync remote: files: "/tmp" (group): unchanged`,
831                                 `4: sync remote: files: "/tmp/safcm-sync-files-test-file" (group): will create`,
832                                 `3: sync remote: files: "/tmp/safcm-sync-files-test-file" (group): creating`,
833                                 `4: sync remote: files: "/tmp/safcm-sync-files-test-file" (group): creating temporary file "/tmp/.safcm-sync-files-test-file*"`,
834                                 `4: sync remote: files: "/tmp/safcm-sync-files-test-file" (group): renaming "/tmp/.safcm-sync-files-test-fileRND"`,
835                                 `3: sync remote: files: "/tmp/safcm-sync-files-test-file": queuing trigger on "/"`,
836                                 `3: sync remote: files: "/tmp/safcm-sync-files-test-file": queuing trigger on "/tmp"`,
837                                 `3: sync remote: files: "/tmp/safcm-sync-files-test-file": queuing trigger on "/tmp/safcm-sync-files-test-file"`,
838                         },
839                         nil,
840                 },
841         }
842
843         for _, tc := range tests {
844                 t.Run(tc.name, func(t *testing.T) {
845                         // Create separate test directory for each test case
846                         path := filepath.Join(cwd, "testdata", "files-"+tc.name)
847                         err = os.Mkdir(path, 0700)
848                         if err != nil {
849                                 t.Fatal(err)
850                         }
851                         err = os.Chdir(path)
852                         if err != nil {
853                                 t.Fatal(err)
854                         }
855
856                         if tc.prepare != nil {
857                                 tc.prepare()
858                         }
859
860                         s, res := prepareSync(tc.req, &testRunner{
861                                 t: t,
862                         })
863                         s.setDefaults()
864
865                         err := s.syncFiles()
866                         // Ugly but the simplest way to compare errors (including nil)
867                         if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", tc.expErr) {
868                                 t.Errorf("err = %#v, want %#v",
869                                         err, tc.expErr)
870                         }
871                         dbg := res.Wait()
872                         // Remove random file names from result
873                         for i, x := range dbg {
874                                 dbg[i] = randFilesRegexp.ReplaceAllString(x, `RND"`)
875                         }
876                         if !reflect.DeepEqual(tc.expDbg, dbg) {
877                                 t.Errorf("dbg: %s",
878                                         cmp.Diff(tc.expDbg, dbg))
879                         }
880
881                         files, err := ft.WalkDir(path)
882                         if err != nil {
883                                 t.Fatal(err)
884                         }
885                         if !reflect.DeepEqual(tc.expFiles, files) {
886                                 t.Errorf("files: %s",
887                                         cmp.Diff(tc.expFiles, files))
888                         }
889
890                         if !reflect.DeepEqual(tc.expResp, s.resp) {
891                                 t.Errorf("resp: %s",
892                                         cmp.Diff(tc.expResp, s.resp))
893                         }
894                         if !reflect.DeepEqual(tc.triggers, s.triggers) {
895                                 t.Errorf("triggers: %s",
896                                         cmp.Diff(tc.triggers, s.triggers))
897                         }
898                 })
899         }
900
901         os.Remove(tmpTestFilePath)
902         if !t.Failed() {
903                 err = os.RemoveAll(filepath.Join(cwd, "testdata"))
904                 if err != nil {
905                         t.Fatal(err)
906                 }
907         }
908 }
909
910 func TestSyncFile(t *testing.T) {
911         cwd, err := os.Getwd()
912         if err != nil {
913                 t.Fatal(err)
914         }
915         defer os.Chdir(cwd)
916
917         err = os.RemoveAll("testdata")
918         if err != nil {
919                 t.Fatal(err)
920         }
921         err = os.Mkdir("testdata", 0700)
922         if err != nil {
923                 t.Fatal(err)
924         }
925
926         root := ft.File{
927                 Path: ".",
928                 Mode: fs.ModeDir | 0700,
929         }
930         user, uid, group, gid := ft.CurrentUserAndGroup()
931
932         tests := []struct {
933                 name       string
934                 req        safcm.MsgSyncReq
935                 file       *safcm.File
936                 prepare    func()
937                 expChanged bool
938                 expFiles   []ft.File
939                 expResp    safcm.MsgSyncResp
940                 expDbg     []string
941                 expErr     error
942         }{
943
944                 // NOTE: Also update MsgSyncResp in safcm test cases when
945                 // changing anything here!
946
947                 // TODO: Add tests for chown and run them only as root
948
949                 // Regular file
950
951                 {
952                         "file: create",
953                         safcm.MsgSyncReq{},
954                         &safcm.File{
955                                 Path:      "file",
956                                 Mode:      0644,
957                                 Uid:       -1,
958                                 Gid:       -1,
959                                 Data:      []byte("content\n"),
960                                 OrigGroup: "group",
961                         },
962                         nil,
963                         true,
964                         []ft.File{
965                                 root,
966                                 {
967                                         Path: "file",
968                                         Mode: 0644,
969                                         Data: []byte("content\n"),
970                                 },
971                         },
972                         safcm.MsgSyncResp{
973                                 FileChanges: []safcm.FileChange{
974                                         {
975                                                 Path:    "file",
976                                                 Created: true,
977                                                 New: safcm.FileChangeInfo{
978                                                         Mode:  0644,
979                                                         User:  user,
980                                                         Uid:   uid,
981                                                         Group: group,
982                                                         Gid:   gid,
983                                                 },
984                                         },
985                                 },
986                         },
987                         []string{
988                                 `4: sync remote: files: "file" (group): will create`,
989                                 `3: sync remote: files: "file" (group): creating`,
990                                 `4: sync remote: files: "file" (group): creating temporary file ".file*"`,
991                                 `4: sync remote: files: "file" (group): renaming "./.fileRND"`,
992                         },
993                         nil,
994                 },
995                 {
996                         "file: create (dry-run)",
997                         safcm.MsgSyncReq{
998                                 DryRun: true,
999                         },
1000                         &safcm.File{
1001                                 Path:      "file",
1002                                 Mode:      0644,
1003                                 Uid:       -1,
1004                                 Gid:       -1,
1005                                 Data:      []byte("content\n"),
1006                                 OrigGroup: "group",
1007                         },
1008                         nil,
1009                         true,
1010                         []ft.File{root},
1011                         safcm.MsgSyncResp{
1012                                 FileChanges: []safcm.FileChange{
1013                                         {
1014                                                 Path:    "file",
1015                                                 Created: true,
1016                                                 New: safcm.FileChangeInfo{
1017                                                         Mode:  0644,
1018                                                         User:  user,
1019                                                         Uid:   uid,
1020                                                         Group: group,
1021                                                         Gid:   gid,
1022                                                 },
1023                                         },
1024                                 },
1025                         },
1026                         []string{
1027                                 `4: sync remote: files: "file" (group): will create`,
1028                                 `3: sync remote: files: "file" (group): creating`,
1029                                 `4: sync remote: files: "file" (group): dry-run, skipping changes`,
1030                         },
1031                         nil,
1032                 },
1033
1034                 {
1035                         "file: unchanged",
1036                         safcm.MsgSyncReq{},
1037                         &safcm.File{
1038                                 Path:      "file",
1039                                 Mode:      0644,
1040                                 Uid:       -1,
1041                                 Gid:       -1,
1042                                 Data:      []byte("content\n"),
1043                                 OrigGroup: "group",
1044                         },
1045                         func() {
1046                                 ft.CreateFile("file", "content\n", 0644)
1047                         },
1048                         false,
1049                         []ft.File{
1050                                 root,
1051                                 {
1052                                         Path: "file",
1053                                         Mode: 0644,
1054                                         Data: []byte("content\n"),
1055                                 },
1056                         },
1057                         safcm.MsgSyncResp{},
1058                         []string{
1059                                 `4: sync remote: files: "file" (group): unchanged`,
1060                         },
1061                         nil,
1062                 },
1063
1064                 {
1065                         "file: unchanged (non-default user-group)",
1066                         safcm.MsgSyncReq{},
1067                         &safcm.File{
1068                                 Path:      "file",
1069                                 Mode:      0644,
1070                                 User:      user,
1071                                 Uid:       -1,
1072                                 Group:     group,
1073                                 Gid:       -1,
1074                                 Data:      []byte("content\n"),
1075                                 OrigGroup: "group",
1076                         },
1077                         func() {
1078                                 ft.CreateFile("file", "content\n", 0644)
1079                         },
1080                         false,
1081                         []ft.File{
1082                                 root,
1083                                 {
1084                                         Path: "file",
1085                                         Mode: 0644,
1086                                         Data: []byte("content\n"),
1087                                 },
1088                         },
1089                         safcm.MsgSyncResp{},
1090                         []string{
1091                                 `4: sync remote: files: "file" (group): unchanged`,
1092                         },
1093                         nil,
1094                 },
1095
1096                 {
1097                         "file: permission",
1098                         safcm.MsgSyncReq{},
1099                         &safcm.File{
1100                                 Path:      "file",
1101                                 Mode:      0755 | fs.ModeSetuid,
1102                                 Uid:       -1,
1103                                 Gid:       -1,
1104                                 Data:      []byte("content\n"),
1105                                 OrigGroup: "group",
1106                         },
1107                         func() {
1108                                 ft.CreateFile("file", "content\n", 0755)
1109                         },
1110                         true,
1111                         []ft.File{
1112                                 root,
1113                                 {
1114                                         Path: "file",
1115                                         Mode: 0755 | fs.ModeSetuid,
1116                                         Data: []byte("content\n"),
1117                                 },
1118                         },
1119                         safcm.MsgSyncResp{
1120                                 FileChanges: []safcm.FileChange{
1121                                         {
1122                                                 Path: "file",
1123                                                 Old: safcm.FileChangeInfo{
1124                                                         Mode:  0755,
1125                                                         User:  user,
1126                                                         Uid:   uid,
1127                                                         Group: group,
1128                                                         Gid:   gid,
1129                                                 },
1130                                                 New: safcm.FileChangeInfo{
1131                                                         Mode:  0755 | fs.ModeSetuid,
1132                                                         User:  user,
1133                                                         Uid:   uid,
1134                                                         Group: group,
1135                                                         Gid:   gid,
1136                                                 },
1137                                         },
1138                                 },
1139                         },
1140                         []string{
1141                                 `4: sync remote: files: "file" (group): permission differs -rwxr-xr-x -> urwxr-xr-x`,
1142                                 `3: sync remote: files: "file" (group): updating`,
1143                                 `4: sync remote: files: "file" (group): creating temporary file ".file*"`,
1144                                 `4: sync remote: files: "file" (group): renaming "./.fileRND"`,
1145                         },
1146                         nil,
1147                 },
1148
1149                 {
1150                         "file: content",
1151                         safcm.MsgSyncReq{},
1152                         &safcm.File{
1153                                 Path:      "file",
1154                                 Mode:      0644,
1155                                 Uid:       -1,
1156                                 Gid:       -1,
1157                                 Data:      []byte("content\n"),
1158                                 OrigGroup: "group",
1159                         },
1160                         func() {
1161                                 ft.CreateFile("file", "old content\n", 0644)
1162                         },
1163                         true,
1164                         []ft.File{
1165                                 root,
1166                                 {
1167                                         Path: "file",
1168                                         Mode: 0644,
1169                                         Data: []byte("content\n"),
1170                                 },
1171                         },
1172                         safcm.MsgSyncResp{
1173                                 FileChanges: []safcm.FileChange{
1174                                         {
1175                                                 Path: "file",
1176                                                 Old: safcm.FileChangeInfo{
1177                                                         Mode:  0644,
1178                                                         User:  user,
1179                                                         Uid:   uid,
1180                                                         Group: group,
1181                                                         Gid:   gid,
1182                                                 },
1183                                                 New: safcm.FileChangeInfo{
1184                                                         Mode:  0644,
1185                                                         User:  user,
1186                                                         Uid:   uid,
1187                                                         Group: group,
1188                                                         Gid:   gid,
1189                                                 },
1190                                                 DataDiff: `@@ -1,2 +1,2 @@
1191 -old content
1192 +content
1193  
1194 `,
1195                                         },
1196                                 },
1197                         },
1198                         []string{
1199                                 `4: sync remote: files: "file" (group): content differs`,
1200                                 `3: sync remote: files: "file" (group): updating`,
1201                                 `4: sync remote: files: "file" (group): creating temporary file ".file*"`,
1202                                 `4: sync remote: files: "file" (group): renaming "./.fileRND"`,
1203                         },
1204                         nil,
1205                 },
1206
1207                 // Symbolic link
1208
1209                 {
1210                         "symlink: create",
1211                         safcm.MsgSyncReq{},
1212                         &safcm.File{
1213                                 Path:      "link",
1214                                 Mode:      fs.ModeSymlink | 0777,
1215                                 Uid:       -1,
1216                                 Gid:       -1,
1217                                 Data:      []byte("target"),
1218                                 OrigGroup: "group",
1219                         },
1220                         nil,
1221                         true,
1222                         []ft.File{
1223                                 root,
1224                                 {
1225                                         Path: "link",
1226                                         Mode: fs.ModeSymlink | 0777,
1227                                         Data: []byte("target"),
1228                                 },
1229                         },
1230                         safcm.MsgSyncResp{
1231                                 FileChanges: []safcm.FileChange{
1232                                         {
1233                                                 Path:    "link",
1234                                                 Created: true,
1235                                                 New: safcm.FileChangeInfo{
1236                                                         Mode:  fs.ModeSymlink | 0777,
1237                                                         User:  user,
1238                                                         Uid:   uid,
1239                                                         Group: group,
1240                                                         Gid:   gid,
1241                                                 },
1242                                         },
1243                                 },
1244                         },
1245                         []string{
1246                                 `4: sync remote: files: "link" (group): will create`,
1247                                 `3: sync remote: files: "link" (group): creating`,
1248                                 `4: sync remote: files: "link" (group): creating temporary symlink ".linkRND"`,
1249                                 `4: sync remote: files: "link" (group): renaming ".linkRND"`,
1250                         },
1251                         nil,
1252                 },
1253                 {
1254                         "symlink: create (conflict)",
1255                         safcm.MsgSyncReq{},
1256                         &safcm.File{
1257                                 Path:      "link",
1258                                 Mode:      fs.ModeSymlink | 0777,
1259                                 Uid:       -1,
1260                                 Gid:       -1,
1261                                 Data:      []byte("target"),
1262                                 OrigGroup: "group",
1263                         },
1264                         func() {
1265                                 ft.CreateFile(".link8717895732742165505", "", 0600)
1266                         },
1267                         true,
1268                         []ft.File{
1269                                 root,
1270                                 {
1271                                         Path: ".link8717895732742165505",
1272                                         Mode: 0600,
1273                                         Data: []byte(""),
1274                                 },
1275                                 {
1276                                         Path: "link",
1277                                         Mode: fs.ModeSymlink | 0777,
1278                                         Data: []byte("target"),
1279                                 },
1280                         },
1281                         safcm.MsgSyncResp{
1282                                 FileChanges: []safcm.FileChange{
1283                                         {
1284                                                 Path:    "link",
1285                                                 Created: true,
1286                                                 New: safcm.FileChangeInfo{
1287                                                         Mode:  fs.ModeSymlink | 0777,
1288                                                         User:  user,
1289                                                         Uid:   uid,
1290                                                         Group: group,
1291                                                         Gid:   gid,
1292                                                 },
1293                                         },
1294                                 },
1295                         },
1296                         []string{
1297                                 `4: sync remote: files: "link" (group): will create`,
1298                                 `3: sync remote: files: "link" (group): creating`,
1299                                 `4: sync remote: files: "link" (group): creating temporary symlink ".linkRND"`,
1300                                 `4: sync remote: files: "link" (group): creating temporary symlink ".linkRND"`,
1301                                 `4: sync remote: files: "link" (group): renaming ".linkRND"`,
1302                         },
1303                         nil,
1304                 },
1305                 {
1306                         "symlink: create (dry-run)",
1307                         safcm.MsgSyncReq{
1308                                 DryRun: true,
1309                         },
1310                         &safcm.File{
1311                                 Path:      "link",
1312                                 Mode:      fs.ModeSymlink | 0777,
1313                                 Uid:       -1,
1314                                 Gid:       -1,
1315                                 Data:      []byte("target"),
1316                                 OrigGroup: "group",
1317                         },
1318                         nil,
1319                         true,
1320                         []ft.File{root},
1321                         safcm.MsgSyncResp{
1322                                 FileChanges: []safcm.FileChange{
1323                                         {
1324                                                 Path:    "link",
1325                                                 Created: true,
1326                                                 New: safcm.FileChangeInfo{
1327                                                         Mode:  fs.ModeSymlink | 0777,
1328                                                         User:  user,
1329                                                         Uid:   uid,
1330                                                         Group: group,
1331                                                         Gid:   gid,
1332                                                 },
1333                                         },
1334                                 },
1335                         },
1336                         []string{
1337                                 `4: sync remote: files: "link" (group): will create`,
1338                                 `3: sync remote: files: "link" (group): creating`,
1339                                 `4: sync remote: files: "link" (group): dry-run, skipping changes`,
1340                         },
1341                         nil,
1342                 },
1343
1344                 {
1345                         "symlink: unchanged",
1346                         safcm.MsgSyncReq{},
1347                         &safcm.File{
1348                                 Path:      "link",
1349                                 Mode:      fs.ModeSymlink | 0777,
1350                                 Uid:       -1,
1351                                 Gid:       -1,
1352                                 Data:      []byte("target"),
1353                                 OrigGroup: "group",
1354                         },
1355                         func() {
1356                                 ft.CreateSymlink("link", "target")
1357                         },
1358                         false,
1359                         []ft.File{
1360                                 root,
1361                                 {
1362                                         Path: "link",
1363                                         Mode: fs.ModeSymlink | 0777,
1364                                         Data: []byte("target"),
1365                                 },
1366                         },
1367                         safcm.MsgSyncResp{},
1368                         []string{
1369                                 `4: sync remote: files: "link" (group): unchanged`,
1370                         },
1371                         nil,
1372                 },
1373
1374                 {
1375                         "symlink: content",
1376                         safcm.MsgSyncReq{},
1377                         &safcm.File{
1378                                 Path:      "link",
1379                                 Mode:      fs.ModeSymlink | 0777,
1380                                 Uid:       -1,
1381                                 Gid:       -1,
1382                                 Data:      []byte("target"),
1383                                 OrigGroup: "group",
1384                         },
1385                         func() {
1386                                 ft.CreateSymlink("link", "old-target")
1387                         },
1388                         true,
1389                         []ft.File{
1390                                 root,
1391                                 {
1392                                         Path: "link",
1393                                         Mode: fs.ModeSymlink | 0777,
1394                                         Data: []byte("target"),
1395                                 },
1396                         },
1397                         safcm.MsgSyncResp{
1398                                 FileChanges: []safcm.FileChange{
1399                                         {
1400                                                 Path: "link",
1401                                                 Old: safcm.FileChangeInfo{
1402                                                         Mode:  fs.ModeSymlink | 0777,
1403                                                         User:  user,
1404                                                         Uid:   uid,
1405                                                         Group: group,
1406                                                         Gid:   gid,
1407                                                 },
1408                                                 New: safcm.FileChangeInfo{
1409                                                         Mode:  fs.ModeSymlink | 0777,
1410                                                         User:  user,
1411                                                         Uid:   uid,
1412                                                         Group: group,
1413                                                         Gid:   gid,
1414                                                 },
1415                                                 DataDiff: `@@ -1 +1 @@
1416 -old-target
1417 +target
1418 `,
1419                                         },
1420                                 },
1421                         },
1422                         []string{
1423                                 `4: sync remote: files: "link" (group): content differs`,
1424                                 `3: sync remote: files: "link" (group): updating`,
1425                                 `4: sync remote: files: "link" (group): creating temporary symlink ".linkRND"`,
1426                                 `4: sync remote: files: "link" (group): renaming ".linkRND"`,
1427                         },
1428                         nil,
1429                 },
1430
1431                 // Directory
1432
1433                 {
1434                         "directory: create",
1435                         safcm.MsgSyncReq{},
1436                         &safcm.File{
1437                                 Path:      "dir",
1438                                 Mode:      fs.ModeDir | 0705,
1439                                 Uid:       -1,
1440                                 Gid:       -1,
1441                                 OrigGroup: "group",
1442                         },
1443                         nil,
1444                         true,
1445                         []ft.File{
1446                                 root,
1447                                 {
1448                                         Path: "dir",
1449                                         Mode: fs.ModeDir | 0705,
1450                                 },
1451                         },
1452                         safcm.MsgSyncResp{
1453                                 FileChanges: []safcm.FileChange{
1454                                         {
1455                                                 Path:    "dir",
1456                                                 Created: true,
1457                                                 New: safcm.FileChangeInfo{
1458                                                         Mode:  fs.ModeDir | 0705,
1459                                                         User:  user,
1460                                                         Uid:   uid,
1461                                                         Group: group,
1462                                                         Gid:   gid,
1463                                                 },
1464                                         },
1465                                 },
1466                         },
1467                         []string{
1468                                 `4: sync remote: files: "dir" (group): will create`,
1469                                 `3: sync remote: files: "dir" (group): creating`,
1470                                 `4: sync remote: files: "dir" (group): creating directory`,
1471                                 `4: sync remote: files: "dir" (group): chmodding drwx---r-x`,
1472                                 fmt.Sprintf(`4: sync remote: files: "dir" (group): chowning %d/%d`, uid, gid),
1473                         },
1474                         nil,
1475                 },
1476                 {
1477                         "directory: create (dry-run)",
1478                         safcm.MsgSyncReq{
1479                                 DryRun: true,
1480                         },
1481                         &safcm.File{
1482                                 Path:      "dir",
1483                                 Mode:      fs.ModeDir | 0644,
1484                                 Uid:       -1,
1485                                 Gid:       -1,
1486                                 OrigGroup: "group",
1487                         },
1488                         nil,
1489                         true,
1490                         []ft.File{root},
1491                         safcm.MsgSyncResp{
1492                                 FileChanges: []safcm.FileChange{
1493                                         {
1494                                                 Path:    "dir",
1495                                                 Created: true,
1496                                                 New: safcm.FileChangeInfo{
1497                                                         Mode:  fs.ModeDir | 0644,
1498                                                         User:  user,
1499                                                         Uid:   uid,
1500                                                         Group: group,
1501                                                         Gid:   gid,
1502                                                 },
1503                                         },
1504                                 },
1505                         },
1506                         []string{
1507                                 `4: sync remote: files: "dir" (group): will create`,
1508                                 `3: sync remote: files: "dir" (group): creating`,
1509                                 `4: sync remote: files: "dir" (group): dry-run, skipping changes`,
1510                         },
1511                         nil,
1512                 },
1513
1514                 {
1515                         "directory: unchanged",
1516                         safcm.MsgSyncReq{},
1517                         &safcm.File{
1518                                 Path:      "dir",
1519                                 Mode:      fs.ModeDir | 0755,
1520                                 Uid:       -1,
1521                                 Gid:       -1,
1522                                 OrigGroup: "group",
1523                         },
1524                         func() {
1525                                 ft.CreateDirectory("dir", 0755)
1526                         },
1527                         false,
1528                         []ft.File{
1529                                 root,
1530                                 {
1531                                         Path: "dir",
1532                                         Mode: fs.ModeDir | 0755,
1533                                 },
1534                         },
1535                         safcm.MsgSyncResp{},
1536                         []string{
1537                                 `4: sync remote: files: "dir" (group): unchanged`,
1538                         },
1539                         nil,
1540                 },
1541
1542                 {
1543                         "directory: permission",
1544                         safcm.MsgSyncReq{},
1545                         &safcm.File{
1546                                 Path:      "dir",
1547                                 Mode:      fs.ModeDir | 0755 | fs.ModeSetgid,
1548                                 Uid:       -1,
1549                                 Gid:       -1,
1550                                 OrigGroup: "group",
1551                         },
1552                         func() {
1553                                 ft.CreateDirectory("dir", 0500|fs.ModeSticky)
1554                         },
1555                         true,
1556                         []ft.File{
1557                                 root,
1558                                 {
1559                                         Path: "dir",
1560                                         Mode: fs.ModeDir | 0755 | fs.ModeSetgid,
1561                                 },
1562                         },
1563                         safcm.MsgSyncResp{
1564                                 FileChanges: []safcm.FileChange{
1565                                         {
1566                                                 Path: "dir",
1567                                                 Old: safcm.FileChangeInfo{
1568                                                         Mode:  fs.ModeDir | 0500 | fs.ModeSticky,
1569                                                         User:  user,
1570                                                         Uid:   uid,
1571                                                         Group: group,
1572                                                         Gid:   gid,
1573                                                 },
1574                                                 New: safcm.FileChangeInfo{
1575                                                         Mode:  fs.ModeDir | 0755 | fs.ModeSetgid,
1576                                                         User:  user,
1577                                                         Uid:   uid,
1578                                                         Group: group,
1579                                                         Gid:   gid,
1580                                                 },
1581                                         },
1582                                 },
1583                         },
1584                         []string{
1585                                 `4: sync remote: files: "dir" (group): permission differs dtr-x------ -> dgrwxr-xr-x`,
1586                                 `3: sync remote: files: "dir" (group): updating`,
1587                                 `4: sync remote: files: "dir" (group): chmodding dgrwxr-xr-x`,
1588                         },
1589                         nil,
1590                 },
1591
1592                 // Type changes
1593
1594                 {
1595                         "change: file to directory",
1596                         safcm.MsgSyncReq{},
1597                         &safcm.File{
1598                                 Path:      "path",
1599                                 Mode:      fs.ModeDir | 0751,
1600                                 Uid:       -1,
1601                                 Gid:       -1,
1602                                 OrigGroup: "group",
1603                         },
1604                         func() {
1605                                 ft.CreateFile("path", "content\n", 0644)
1606                         },
1607                         true,
1608                         []ft.File{
1609                                 root,
1610                                 {
1611                                         Path: "path",
1612                                         Mode: fs.ModeDir | 0751,
1613                                 },
1614                         },
1615                         safcm.MsgSyncResp{
1616                                 FileChanges: []safcm.FileChange{
1617                                         {
1618                                                 Path: "path",
1619                                                 Old: safcm.FileChangeInfo{
1620                                                         Mode:  0644,
1621                                                         User:  user,
1622                                                         Uid:   uid,
1623                                                         Group: group,
1624                                                         Gid:   gid,
1625                                                 },
1626                                                 New: safcm.FileChangeInfo{
1627                                                         Mode:  fs.ModeDir | 0751,
1628                                                         User:  user,
1629                                                         Uid:   uid,
1630                                                         Group: group,
1631                                                         Gid:   gid,
1632                                                 },
1633                                                 DataDiff: `@@ -1,2 +1 @@
1634 -content
1635  
1636 `,
1637                                         },
1638                                 },
1639                         },
1640                         []string{
1641                                 `4: sync remote: files: "path" (group): type differs ---------- -> d---------`,
1642                                 `3: sync remote: files: "path" (group): updating`,
1643                                 `4: sync remote: files: "path" (group): removing (due to type change)`,
1644                                 `4: sync remote: files: "path" (group): creating directory`,
1645                                 `4: sync remote: files: "path" (group): chmodding drwxr-x--x`,
1646                                 fmt.Sprintf(`4: sync remote: files: "path" (group): chowning %d/%d`, uid, gid),
1647                         },
1648                         nil,
1649                 },
1650
1651                 {
1652                         "change: file to symlink",
1653                         safcm.MsgSyncReq{},
1654                         &safcm.File{
1655                                 Path:      "path",
1656                                 Mode:      fs.ModeSymlink | 0777,
1657                                 Uid:       -1,
1658                                 Gid:       -1,
1659                                 OrigGroup: "group",
1660                                 Data:      []byte("target"),
1661                         },
1662                         func() {
1663                                 ft.CreateFile("path", "content\n", 0644)
1664                         },
1665                         true,
1666                         []ft.File{
1667                                 root,
1668                                 {
1669                                         Path: "path",
1670                                         Mode: fs.ModeSymlink | 0777,
1671                                         Data: []byte("target"),
1672                                 },
1673                         },
1674                         safcm.MsgSyncResp{
1675                                 FileChanges: []safcm.FileChange{
1676                                         {
1677                                                 Path: "path",
1678                                                 Old: safcm.FileChangeInfo{
1679                                                         Mode:  0644,
1680                                                         User:  user,
1681                                                         Uid:   uid,
1682                                                         Group: group,
1683                                                         Gid:   gid,
1684                                                 },
1685                                                 New: safcm.FileChangeInfo{
1686                                                         Mode:  fs.ModeSymlink | 0777,
1687                                                         User:  user,
1688                                                         Uid:   uid,
1689                                                         Group: group,
1690                                                         Gid:   gid,
1691                                                 },
1692                                                 DataDiff: `@@ -1,2 +1 @@
1693 -content
1694 -
1695 +target
1696 `,
1697                                         },
1698                                 },
1699                         },
1700                         []string{
1701                                 `4: sync remote: files: "path" (group): type differs ---------- -> L---------`,
1702                                 `3: sync remote: files: "path" (group): updating`,
1703                                 `4: sync remote: files: "path" (group): creating temporary symlink ".pathRND"`,
1704                                 `4: sync remote: files: "path" (group): renaming ".pathRND"`,
1705                         },
1706                         nil,
1707                 },
1708
1709                 {
1710                         "change: symlink to file",
1711                         safcm.MsgSyncReq{},
1712                         &safcm.File{
1713                                 Path:      "path",
1714                                 Mode:      0640,
1715                                 Uid:       -1,
1716                                 Gid:       -1,
1717                                 OrigGroup: "group",
1718                                 Data:      []byte("content\n"),
1719                         },
1720                         func() {
1721                                 ft.CreateSymlink("path", "target")
1722                         },
1723                         true,
1724                         []ft.File{
1725                                 root,
1726                                 {
1727                                         Path: "path",
1728                                         Mode: 0640,
1729                                         Data: []byte("content\n"),
1730                                 },
1731                         },
1732                         safcm.MsgSyncResp{
1733                                 FileChanges: []safcm.FileChange{
1734                                         {
1735                                                 Path: "path",
1736                                                 Old: safcm.FileChangeInfo{
1737                                                         Mode:  fs.ModeSymlink | 0777,
1738                                                         User:  user,
1739                                                         Uid:   uid,
1740                                                         Group: group,
1741                                                         Gid:   gid,
1742                                                 },
1743                                                 New: safcm.FileChangeInfo{
1744                                                         Mode:  0640,
1745                                                         User:  user,
1746                                                         Uid:   uid,
1747                                                         Group: group,
1748                                                         Gid:   gid,
1749                                                 },
1750                                                 DataDiff: `@@ -1 +1,2 @@
1751 -target
1752 +content
1753 +
1754 `,
1755                                         },
1756                                 },
1757                         },
1758                         []string{
1759                                 `4: sync remote: files: "path" (group): type differs L--------- -> ----------`,
1760                                 `3: sync remote: files: "path" (group): updating`,
1761                                 `4: sync remote: files: "path" (group): creating temporary file ".path*"`,
1762                                 `4: sync remote: files: "path" (group): renaming "./.pathRND"`,
1763                         },
1764                         nil,
1765                 },
1766
1767                 {
1768                         "change: symlink to directory",
1769                         safcm.MsgSyncReq{},
1770                         &safcm.File{
1771                                 Path:      "path",
1772                                 Mode:      fs.ModeDir | 0751,
1773                                 Uid:       -1,
1774                                 Gid:       -1,
1775                                 OrigGroup: "group",
1776                         },
1777                         func() {
1778                                 ft.CreateSymlink("path", "target")
1779                         },
1780                         true,
1781                         []ft.File{
1782                                 root,
1783                                 {
1784                                         Path: "path",
1785                                         Mode: fs.ModeDir | 0751,
1786                                 },
1787                         },
1788                         safcm.MsgSyncResp{
1789                                 FileChanges: []safcm.FileChange{
1790                                         {
1791                                                 Path: "path",
1792                                                 Old: safcm.FileChangeInfo{
1793                                                         Mode:  fs.ModeSymlink | 0777,
1794                                                         User:  user,
1795                                                         Uid:   uid,
1796                                                         Group: group,
1797                                                         Gid:   gid,
1798                                                 },
1799                                                 New: safcm.FileChangeInfo{
1800                                                         Mode:  fs.ModeDir | 0751,
1801                                                         User:  user,
1802                                                         Uid:   uid,
1803                                                         Group: group,
1804                                                         Gid:   gid,
1805                                                 },
1806                                                 DataDiff: `@@ -1 +1 @@
1807 -target
1808 +
1809 `,
1810                                         },
1811                                 },
1812                         },
1813                         []string{
1814                                 `4: sync remote: files: "path" (group): type differs L--------- -> d---------`,
1815                                 `3: sync remote: files: "path" (group): updating`,
1816                                 `4: sync remote: files: "path" (group): removing (due to type change)`,
1817                                 `4: sync remote: files: "path" (group): creating directory`,
1818                                 `4: sync remote: files: "path" (group): chmodding drwxr-x--x`,
1819                                 fmt.Sprintf(`4: sync remote: files: "path" (group): chowning %d/%d`, uid, gid),
1820                         },
1821                         nil,
1822                 },
1823
1824                 {
1825                         "change: directory to file",
1826                         safcm.MsgSyncReq{},
1827                         &safcm.File{
1828                                 Path:      "path",
1829                                 Mode:      0666,
1830                                 Uid:       -1,
1831                                 Gid:       -1,
1832                                 OrigGroup: "group",
1833                                 Data:      []byte("content\n"),
1834                         },
1835                         func() {
1836                                 ft.CreateDirectory("path", 0777)
1837                         },
1838                         true,
1839                         []ft.File{
1840                                 root,
1841                                 {
1842                                         Path: "path",
1843                                         Mode: 0666,
1844                                         Data: []byte("content\n"),
1845                                 },
1846                         },
1847                         safcm.MsgSyncResp{
1848                                 FileChanges: []safcm.FileChange{
1849                                         {
1850                                                 Path: "path",
1851                                                 Old: safcm.FileChangeInfo{
1852                                                         Mode:  fs.ModeDir | 0777,
1853                                                         User:  user,
1854                                                         Uid:   uid,
1855                                                         Group: group,
1856                                                         Gid:   gid,
1857                                                 },
1858                                                 New: safcm.FileChangeInfo{
1859                                                         Mode:  0666,
1860                                                         User:  user,
1861                                                         Uid:   uid,
1862                                                         Group: group,
1863                                                         Gid:   gid,
1864                                                 },
1865                                         },
1866                                 },
1867                         },
1868                         []string{
1869                                 `4: sync remote: files: "path" (group): type differs d--------- -> ----------`,
1870                                 `3: sync remote: files: "path" (group): updating`,
1871                                 `4: sync remote: files: "path" (group): removing (due to type change)`,
1872                                 `4: sync remote: files: "path" (group): creating temporary file ".path*"`,
1873                                 `4: sync remote: files: "path" (group): renaming "./.pathRND"`,
1874                         },
1875                         nil,
1876                 },
1877
1878                 {
1879                         "change: directory to symlink",
1880                         safcm.MsgSyncReq{},
1881                         &safcm.File{
1882                                 Path:      "path",
1883                                 Mode:      fs.ModeSymlink | 0777,
1884                                 Uid:       -1,
1885                                 Gid:       -1,
1886                                 OrigGroup: "group",
1887                                 Data:      []byte("target"),
1888                         },
1889                         func() {
1890                                 ft.CreateDirectory("path", 0777)
1891                         },
1892                         true,
1893                         []ft.File{
1894                                 root,
1895                                 {
1896                                         Path: "path",
1897                                         Mode: fs.ModeSymlink | 0777,
1898                                         Data: []byte("target"),
1899                                 },
1900                         },
1901                         safcm.MsgSyncResp{
1902                                 FileChanges: []safcm.FileChange{
1903                                         {
1904                                                 Path: "path",
1905                                                 Old: safcm.FileChangeInfo{
1906                                                         Mode:  fs.ModeDir | 0777,
1907                                                         User:  user,
1908                                                         Uid:   uid,
1909                                                         Group: group,
1910                                                         Gid:   gid,
1911                                                 },
1912                                                 New: safcm.FileChangeInfo{
1913                                                         Mode:  fs.ModeSymlink | 0777,
1914                                                         User:  user,
1915                                                         Uid:   uid,
1916                                                         Group: group,
1917                                                         Gid:   gid,
1918                                                 },
1919                                         },
1920                                 },
1921                         },
1922                         []string{
1923                                 `4: sync remote: files: "path" (group): type differs d--------- -> L---------`,
1924                                 `3: sync remote: files: "path" (group): updating`,
1925                                 `4: sync remote: files: "path" (group): removing (due to type change)`,
1926                                 `4: sync remote: files: "path" (group): creating temporary symlink ".pathRND"`,
1927                                 `4: sync remote: files: "path" (group): renaming ".pathRND"`,
1928                         },
1929                         nil,
1930                 },
1931
1932                 {
1933                         "change: other to file",
1934                         safcm.MsgSyncReq{},
1935                         &safcm.File{
1936                                 Path:      "path",
1937                                 Mode:      0640,
1938                                 Uid:       -1,
1939                                 Gid:       -1,
1940                                 OrigGroup: "group",
1941                                 Data:      []byte("content\n"),
1942                         },
1943                         func() {
1944                                 ft.CreateFifo("path", 0666)
1945                         },
1946                         true,
1947                         []ft.File{
1948                                 root,
1949                                 {
1950                                         Path: "path",
1951                                         Mode: 0640,
1952                                         Data: []byte("content\n"),
1953                                 },
1954                         },
1955                         safcm.MsgSyncResp{
1956                                 FileChanges: []safcm.FileChange{
1957                                         {
1958                                                 Path: "path",
1959                                                 Old: safcm.FileChangeInfo{
1960                                                         Mode:  fs.ModeNamedPipe | 0666,
1961                                                         User:  user,
1962                                                         Uid:   uid,
1963                                                         Group: group,
1964                                                         Gid:   gid,
1965                                                 },
1966                                                 New: safcm.FileChangeInfo{
1967                                                         Mode:  0640,
1968                                                         User:  user,
1969                                                         Uid:   uid,
1970                                                         Group: group,
1971                                                         Gid:   gid,
1972                                                 },
1973                                         },
1974                                 },
1975                         },
1976                         []string{
1977                                 `4: sync remote: files: "path" (group): type differs p--------- -> ----------`,
1978                                 `3: sync remote: files: "path" (group): updating`,
1979                                 `4: sync remote: files: "path" (group): creating temporary file ".path*"`,
1980                                 `4: sync remote: files: "path" (group): renaming "./.pathRND"`,
1981                         },
1982                         nil,
1983                 },
1984
1985                 {
1986                         "change: other to symlink",
1987                         safcm.MsgSyncReq{},
1988                         &safcm.File{
1989                                 Path:      "path",
1990                                 Mode:      fs.ModeSymlink | 0777,
1991                                 Uid:       -1,
1992                                 Gid:       -1,
1993                                 OrigGroup: "group",
1994                                 Data:      []byte("target"),
1995                         },
1996                         func() {
1997                                 ft.CreateFifo("path", 0666)
1998                         },
1999                         true,
2000                         []ft.File{
2001                                 root,
2002                                 {
2003                                         Path: "path",
2004                                         Mode: fs.ModeSymlink | 0777,
2005                                         Data: []byte("target"),
2006                                 },
2007                         },
2008                         safcm.MsgSyncResp{
2009                                 FileChanges: []safcm.FileChange{
2010                                         {
2011                                                 Path: "path",
2012                                                 Old: safcm.FileChangeInfo{
2013                                                         Mode:  fs.ModeNamedPipe | 0666,
2014                                                         User:  user,
2015                                                         Uid:   uid,
2016                                                         Group: group,
2017                                                         Gid:   gid,
2018                                                 },
2019                                                 New: safcm.FileChangeInfo{
2020                                                         Mode:  fs.ModeSymlink | 0777,
2021                                                         User:  user,
2022                                                         Uid:   uid,
2023                                                         Group: group,
2024                                                         Gid:   gid,
2025                                                 },
2026                                         },
2027                                 },
2028                         },
2029                         []string{
2030                                 `4: sync remote: files: "path" (group): type differs p--------- -> L---------`,
2031                                 `3: sync remote: files: "path" (group): updating`,
2032                                 `4: sync remote: files: "path" (group): creating temporary symlink ".pathRND"`,
2033                                 `4: sync remote: files: "path" (group): renaming ".pathRND"`,
2034                         },
2035                         nil,
2036                 },
2037
2038                 {
2039                         "change: other to directory",
2040                         safcm.MsgSyncReq{},
2041                         &safcm.File{
2042                                 Path:      "path",
2043                                 Mode:      fs.ModeDir | 0751,
2044                                 Uid:       -1,
2045                                 Gid:       -1,
2046                                 OrigGroup: "group",
2047                         },
2048                         func() {
2049                                 ft.CreateFifo("path", 0666)
2050                         },
2051                         true,
2052                         []ft.File{
2053                                 root,
2054                                 {
2055                                         Path: "path",
2056                                         Mode: fs.ModeDir | 0751,
2057                                 },
2058                         },
2059                         safcm.MsgSyncResp{
2060                                 FileChanges: []safcm.FileChange{
2061                                         {
2062                                                 Path: "path",
2063                                                 Old: safcm.FileChangeInfo{
2064                                                         Mode:  fs.ModeNamedPipe | 0666,
2065                                                         User:  user,
2066                                                         Uid:   uid,
2067                                                         Group: group,
2068                                                         Gid:   gid,
2069                                                 },
2070                                                 New: safcm.FileChangeInfo{
2071                                                         Mode:  fs.ModeDir | 0751,
2072                                                         User:  user,
2073                                                         Uid:   uid,
2074                                                         Group: group,
2075                                                         Gid:   gid,
2076                                                 },
2077                                         },
2078                                 },
2079                         },
2080                         []string{
2081                                 `4: sync remote: files: "path" (group): type differs p--------- -> d---------`,
2082                                 `3: sync remote: files: "path" (group): updating`,
2083                                 `4: sync remote: files: "path" (group): removing (due to type change)`,
2084                                 `4: sync remote: files: "path" (group): creating directory`,
2085                                 `4: sync remote: files: "path" (group): chmodding drwxr-x--x`,
2086                                 fmt.Sprintf(`4: sync remote: files: "path" (group): chowning %d/%d`, uid, gid),
2087                         },
2088                         nil,
2089                 },
2090
2091                 {
2092                         "change: file to symlink (same content)",
2093                         safcm.MsgSyncReq{},
2094                         &safcm.File{
2095                                 Path:      "path",
2096                                 Mode:      fs.ModeSymlink | 0777,
2097                                 Uid:       -1,
2098                                 Gid:       -1,
2099                                 OrigGroup: "group",
2100                                 Data:      []byte("target"),
2101                         },
2102                         func() {
2103                                 ft.CreateFile("path", "target", 0644)
2104                         },
2105                         true,
2106                         []ft.File{
2107                                 root,
2108                                 {
2109                                         Path: "path",
2110                                         Mode: fs.ModeSymlink | 0777,
2111                                         Data: []byte("target"),
2112                                 },
2113                         },
2114                         safcm.MsgSyncResp{
2115                                 FileChanges: []safcm.FileChange{
2116                                         {
2117                                                 Path: "path",
2118                                                 Old: safcm.FileChangeInfo{
2119                                                         Mode:  0644,
2120                                                         User:  user,
2121                                                         Uid:   uid,
2122                                                         Group: group,
2123                                                         Gid:   gid,
2124                                                 },
2125                                                 New: safcm.FileChangeInfo{
2126                                                         Mode:  fs.ModeSymlink | 0777,
2127                                                         User:  user,
2128                                                         Uid:   uid,
2129                                                         Group: group,
2130                                                         Gid:   gid,
2131                                                 },
2132                                         },
2133                                 },
2134                         },
2135                         []string{
2136                                 `4: sync remote: files: "path" (group): type differs ---------- -> L---------`,
2137                                 `3: sync remote: files: "path" (group): updating`,
2138                                 `4: sync remote: files: "path" (group): creating temporary symlink ".pathRND"`,
2139                                 `4: sync remote: files: "path" (group): renaming ".pathRND"`,
2140                         },
2141                         nil,
2142                 },
2143
2144                 // Diffs
2145
2146                 {
2147                         "diff: textual",
2148                         safcm.MsgSyncReq{
2149                                 DryRun: true,
2150                         },
2151                         &safcm.File{
2152                                 Path: "file",
2153                                 Mode: 0644,
2154                                 Uid:  -1,
2155                                 Gid:  -1,
2156                                 Data: []byte(`
2157 this
2158 is
2159 a
2160 simple
2161 file
2162 `),
2163                                 OrigGroup: "group",
2164                         },
2165                         func() {
2166                                 ft.CreateFile("file", `this
2167 is
2168 file
2169 !
2170 `, 0644)
2171                         },
2172                         true,
2173                         []ft.File{
2174                                 root,
2175                                 {
2176                                         Path: "file",
2177                                         Mode: 0644,
2178                                         Data: []byte(`this
2179 is
2180 file
2181 !
2182 `),
2183                                 },
2184                         },
2185                         safcm.MsgSyncResp{
2186                                 FileChanges: []safcm.FileChange{
2187                                         {
2188                                                 Path: "file",
2189                                                 Old: safcm.FileChangeInfo{
2190                                                         Mode:  0644,
2191                                                         User:  user,
2192                                                         Uid:   uid,
2193                                                         Group: group,
2194                                                         Gid:   gid,
2195                                                 },
2196                                                 New: safcm.FileChangeInfo{
2197                                                         Mode:  0644,
2198                                                         User:  user,
2199                                                         Uid:   uid,
2200                                                         Group: group,
2201                                                         Gid:   gid,
2202                                                 },
2203                                                 DataDiff: `@@ -1,5 +1,7 @@
2204 +
2205  this
2206  is
2207 +a
2208 +simple
2209  file
2210 -!
2211  
2212 `,
2213                                         },
2214                                 },
2215                         },
2216                         []string{
2217                                 `4: sync remote: files: "file" (group): content differs`,
2218                                 `3: sync remote: files: "file" (group): updating`,
2219                                 `4: sync remote: files: "file" (group): dry-run, skipping changes`,
2220                         },
2221                         nil,
2222                 },
2223
2224                 {
2225                         "diff: binary both",
2226                         safcm.MsgSyncReq{
2227                                 DryRun: true,
2228                         },
2229                         &safcm.File{
2230                                 Path:      "file",
2231                                 Mode:      0644,
2232                                 Uid:       -1,
2233                                 Gid:       -1,
2234                                 Data:      []byte("\x00\x01\x02\x03"),
2235                                 OrigGroup: "group",
2236                         },
2237                         func() {
2238                                 ft.CreateFile("file", "\x00\x01\x02", 0644)
2239                         },
2240                         true,
2241                         []ft.File{
2242                                 root,
2243                                 {
2244                                         Path: "file",
2245                                         Mode: 0644,
2246                                         Data: []byte("\x00\x01\x02"),
2247                                 },
2248                         },
2249                         safcm.MsgSyncResp{
2250                                 FileChanges: []safcm.FileChange{
2251                                         {
2252                                                 Path: "file",
2253                                                 Old: safcm.FileChangeInfo{
2254                                                         Mode:  0644,
2255                                                         User:  user,
2256                                                         Uid:   uid,
2257                                                         Group: group,
2258                                                         Gid:   gid,
2259                                                 },
2260                                                 New: safcm.FileChangeInfo{
2261                                                         Mode:  0644,
2262                                                         User:  user,
2263                                                         Uid:   uid,
2264                                                         Group: group,
2265                                                         Gid:   gid,
2266                                                 },
2267                                                 DataDiff: "Binary files differ, cannot show diff",
2268                                         },
2269                                 },
2270                         },
2271                         []string{
2272                                 `4: sync remote: files: "file" (group): content differs`,
2273                                 `3: sync remote: files: "file" (group): updating`,
2274                                 `4: sync remote: files: "file" (group): dry-run, skipping changes`,
2275                         },
2276                         nil,
2277                 },
2278
2279                 {
2280                         "diff: binary old",
2281                         safcm.MsgSyncReq{
2282                                 DryRun: true,
2283                         },
2284                         &safcm.File{
2285                                 Path:      "file",
2286                                 Mode:      0644,
2287                                 Uid:       -1,
2288                                 Gid:       -1,
2289                                 Data:      []byte("content\n"),
2290                                 OrigGroup: "group",
2291                         },
2292                         func() {
2293                                 ft.CreateFile("file", "\x00\x01\x02", 0644)
2294                         },
2295                         true,
2296                         []ft.File{
2297                                 root,
2298                                 {
2299                                         Path: "file",
2300                                         Mode: 0644,
2301                                         Data: []byte("\x00\x01\x02"),
2302                                 },
2303                         },
2304                         safcm.MsgSyncResp{
2305                                 FileChanges: []safcm.FileChange{
2306                                         {
2307                                                 Path: "file",
2308                                                 Old: safcm.FileChangeInfo{
2309                                                         Mode:  0644,
2310                                                         User:  user,
2311                                                         Uid:   uid,
2312                                                         Group: group,
2313                                                         Gid:   gid,
2314                                                 },
2315                                                 New: safcm.FileChangeInfo{
2316                                                         Mode:  0644,
2317                                                         User:  user,
2318                                                         Uid:   uid,
2319                                                         Group: group,
2320                                                         Gid:   gid,
2321                                                 },
2322                                                 DataDiff: `@@ -1,2 +1,2 @@
2323 -<binary content>
2324 +content
2325  
2326 `,
2327                                         },
2328                                 },
2329                         },
2330                         []string{
2331                                 `4: sync remote: files: "file" (group): content differs`,
2332                                 `3: sync remote: files: "file" (group): updating`,
2333                                 `4: sync remote: files: "file" (group): dry-run, skipping changes`,
2334                         },
2335                         nil,
2336                 },
2337
2338                 {
2339                         "diff: binary new",
2340                         safcm.MsgSyncReq{
2341                                 DryRun: true,
2342                         },
2343                         &safcm.File{
2344                                 Path:      "file",
2345                                 Mode:      0644,
2346                                 Uid:       -1,
2347                                 Gid:       -1,
2348                                 Data:      []byte("\x00\x01\x02\x03"),
2349                                 OrigGroup: "group",
2350                         },
2351                         func() {
2352                                 ft.CreateFile("file", "content\n", 0644)
2353                         },
2354                         true,
2355                         []ft.File{
2356                                 root,
2357                                 {
2358                                         Path: "file",
2359                                         Mode: 0644,
2360                                         Data: []byte("content\n"),
2361                                 },
2362                         },
2363                         safcm.MsgSyncResp{
2364                                 FileChanges: []safcm.FileChange{
2365                                         {
2366                                                 Path: "file",
2367                                                 Old: safcm.FileChangeInfo{
2368                                                         Mode:  0644,
2369                                                         User:  user,
2370                                                         Uid:   uid,
2371                                                         Group: group,
2372                                                         Gid:   gid,
2373                                                 },
2374                                                 New: safcm.FileChangeInfo{
2375                                                         Mode:  0644,
2376                                                         User:  user,
2377                                                         Uid:   uid,
2378                                                         Group: group,
2379                                                         Gid:   gid,
2380                                                 },
2381                                                 DataDiff: `@@ -1,2 +1,2 @@
2382 -content
2383 +<binary content>
2384  
2385 `,
2386                                         },
2387                                 },
2388                         },
2389                         []string{
2390                                 `4: sync remote: files: "file" (group): content differs`,
2391                                 `3: sync remote: files: "file" (group): updating`,
2392                                 `4: sync remote: files: "file" (group): dry-run, skipping changes`,
2393                         },
2394                         nil,
2395                 },
2396         }
2397
2398         for _, tc := range tests {
2399                 t.Run(tc.name, func(t *testing.T) {
2400                         // Create separate test directory for each test case
2401                         path := filepath.Join(cwd, "testdata", "file-"+tc.name)
2402                         err = os.Mkdir(path, 0700)
2403                         if err != nil {
2404                                 t.Fatal(err)
2405                         }
2406                         err = os.Chdir(path)
2407                         if err != nil {
2408                                 t.Fatal(err)
2409                         }
2410
2411                         if tc.prepare != nil {
2412                                 tc.prepare()
2413                         }
2414
2415                         s, res := prepareSync(tc.req, &testRunner{
2416                                 t: t,
2417                         })
2418                         s.setDefaults()
2419
2420                         // Deterministic temporary symlink names
2421                         rand.Seed(0)
2422
2423                         var changed bool
2424                         err := s.syncFile(tc.file, &changed)
2425                         // Ugly but the simplest way to compare errors (including nil)
2426                         if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", tc.expErr) {
2427                                 t.Errorf("err = %#v, want %#v",
2428                                         err, tc.expErr)
2429                         }
2430                         dbg := res.Wait()
2431                         // Remove random file names from result
2432                         for i, x := range dbg {
2433                                 dbg[i] = randFilesRegexp.ReplaceAllString(x, `RND"`)
2434                         }
2435                         if !reflect.DeepEqual(tc.expDbg, dbg) {
2436                                 t.Errorf("dbg: %s",
2437                                         cmp.Diff(tc.expDbg, dbg))
2438                         }
2439
2440                         files, err := ft.WalkDir(path)
2441                         if err != nil {
2442                                 t.Fatal(err)
2443                         }
2444                         if !reflect.DeepEqual(tc.expFiles, files) {
2445                                 t.Errorf("files: %s",
2446                                         cmp.Diff(tc.expFiles, files))
2447                         }
2448
2449                         if tc.expChanged != changed {
2450                                 t.Errorf("changed = %#v, want %#v",
2451                                         changed, tc.expChanged)
2452                         }
2453                         if !reflect.DeepEqual(tc.expResp, s.resp) {
2454                                 t.Errorf("resp: %s",
2455                                         cmp.Diff(tc.expResp, s.resp))
2456                         }
2457                 })
2458         }
2459
2460         if !t.Failed() {
2461                 err = os.RemoveAll(filepath.Join(cwd, "testdata"))
2462                 if err != nil {
2463                         t.Fatal(err)
2464                 }
2465         }
2466 }