tests: go fmt and rewrap

[safcm/safcm.git] / cmd / safcm / sync_sync_test.go

diff --git a/cmd/safcm/sync_sync_test.go b/cmd/safcm/sync_sync_test.go
index 65a490a298518963326cf3597fd720e4e82ddbc0..f3d046a23a0f4618525403fd1158239e8d149dca 100644 (file)
--- a/cmd/safcm/sync_sync_test.go
+++ b/cmd/safcm/sync_sync_test.go
@@ -420,71 +420,71 @@ func TestHostSyncReq(t *testing.T) {
 
        for _, tc := range tests {
                t.Run(tc.name, func(t *testing.T) {
-               err = os.Chdir(filepath.Join(cwd, "testdata", tc.project))
-               if err != nil {
-                       t.Fatal(err)
-               }
+                       err = os.Chdir(filepath.Join(cwd,
+                               "testdata", tc.project))
+                       if err != nil {
+                               t.Fatal(err)
+                       }
 
-               // `safcm fixperms` in case user has strict umask
-               log.SetOutput(io.Discard)
-               err := MainFixperms()
-               if err != nil {
-                       t.Fatal(err)
-               }
-               log.SetOutput(os.Stderr)
+                       // `safcm fixperms` in case user has strict umask
+                       log.SetOutput(io.Discard)
+                       err := MainFixperms()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       log.SetOutput(os.Stderr)
 
-               cfg, allHosts, allGroups, err := LoadBaseFiles()
-               if err != nil {
-                       t.Fatal(err)
-               }
-               cfg.LogLevel = tc.level
+                       cfg, allHosts, allGroups, err := LoadBaseFiles()
+                       if err != nil {
+                               t.Fatal(err)
+                       }
+                       cfg.LogLevel = tc.level
 
-               var events []string
-               ch := make(chan Event)
-               done := make(chan struct{})
-               go func() {
-                       for {
-                               x, ok := <-ch
-                               if !ok {
-                                       break
+                       var events []string
+                       ch := make(chan Event)
+                       done := make(chan struct{})
+                       go func() {
+                               for {
+                                       x, ok := <-ch
+                                       if !ok {
+                                               break
+                                       }
+                                       if x.ConnEvent.Type != 0 {
+                                               panic("unexpected ConnEvent")
+                                       }
+                                       events = append(events,
+                                               fmt.Sprintf("%s: %v %d %s",
+                                                       x.Host.Name,
+                                                       x.Error, x.Log.Level,
+                                                       x.Log.Text))
                                }
-                               if x.ConnEvent.Type != 0 {
-                                       panic("unexpected ConnEvent")
-                               }
-                               events = append(events,
-                                       fmt.Sprintf("%s: %v %d %s",
-                                               x.Host.Name,
-                                               x.Error, x.Log.Level,
-                                               x.Log.Text))
-                       }
-                       done <- struct{}{}
-               }()
+                               done <- struct{}{}
+                       }()
 
-               s := &Sync{
-                       host:      allHosts.Map[tc.host],
-                       config:    cfg,
-                       allHosts:  allHosts,
-                       allGroups: allGroups,
-                       events:    ch,
-               }
+                       s := &Sync{
+                               host:      allHosts.Map[tc.host],
+                               config:    cfg,
+                               allHosts:  allHosts,
+                               allGroups: allGroups,
+                               events:    ch,
+                       }
 
-               res, err := s.hostSyncReq(tc.detected)
-               if !reflect.DeepEqual(tc.exp, res) {
-                       t.Errorf("res: %s",
-                               cmp.Diff(tc.exp, res))
-               }
-               // Ugly but the simplest way to compare errors (including nil)
-               if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", tc.expErr) {
-                       t.Errorf("err = %#v, want %#v",
-                               err, tc.expErr)
-               }
+                       res, err := s.hostSyncReq(tc.detected)
+                       if !reflect.DeepEqual(tc.exp, res) {
+                               t.Errorf("res: %s", cmp.Diff(tc.exp, res))
+                       }
+                       // Ugly but the simplest way to compare errors (including nil)
+                       if fmt.Sprintf("%s", err) != fmt.Sprintf("%s", tc.expErr) {
+                               t.Errorf("err = %#v, want %#v",
+                                       err, tc.expErr)
+                       }
 
-               close(ch)
-               <-done
-               if !reflect.DeepEqual(tc.expEvents, events) {
-                       t.Errorf("events: %s",
-                               cmp.Diff(tc.expEvents, events))
-               }
+                       close(ch)
+                       <-done
+                       if !reflect.DeepEqual(tc.expEvents, events) {
+                               t.Errorf("events: %s",
+                                       cmp.Diff(tc.expEvents, events))
+                       }
                })
        }
 }