]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - cmd/safcm/config/templates_test.go
tests: use filetest.CreateFifo() in config tests
[safcm/safcm.git] / cmd / safcm / config / templates_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 config
17
18 import (
19         "fmt"
20         "io/fs"
21         "os"
22         "testing"
23
24         "ruderich.org/simon/safcm"
25         "ruderich.org/simon/safcm/testutil"
26 )
27
28 func TestLoadTemplates(t *testing.T) {
29         cwd, err := os.Getwd()
30         if err != nil {
31                 t.Fatal(err)
32         }
33         defer os.Chdir(cwd)
34
35         err = os.Chdir("../testdata/project")
36         if err != nil {
37                 t.Fatal(err)
38         }
39
40         allHosts, err := LoadHosts()
41         if err != nil {
42                 t.Fatal(err)
43         }
44         allGroups, err := LoadGroups(&Config{}, allHosts)
45         if err != nil {
46                 t.Fatal(err)
47         }
48         host := "host1.example.org"
49         groups, err := ResolveHostGroups(host, allGroups,
50                 []string{"detected_amd64", "detected_linux"})
51         if err != nil {
52                 t.Fatal(err)
53         }
54
55         tests := []struct {
56                 group  string
57                 exp    map[string]*safcm.File
58                 expErr error
59         }{
60
61                 {
62                         "empty",
63                         nil,
64                         nil,
65                 },
66
67                 {
68                         "group",
69                         map[string]*safcm.File{
70                                 "/": {
71                                         Path: "/",
72                                         Mode: fs.ModeDir | 0755,
73                                         Uid:  -1,
74                                         Gid:  -1,
75                                 },
76                                 "/etc": {
77                                         Path: "/etc",
78                                         Mode: fs.ModeDir | 0755,
79                                         Uid:  -1,
80                                         Gid:  -1,
81                                 },
82                                 "/etc/.hidden": {
83                                         Path: "/etc/.hidden",
84                                         Mode: 0644,
85                                         Uid:  -1,
86                                         Gid:  -1,
87                                         Data: []byte("..."),
88                                 },
89                                 "/etc/motd": {
90                                         Path: "/etc/motd",
91                                         Mode: 0644,
92                                         Uid:  -1,
93                                         Gid:  -1,
94                                         Data: []byte(`Welcome to Host ONE
95
96
97 This is GNU/Linux host
98
99
100
101
102 all
103
104
105 host1.example.org
106
107
108
109 `),
110                                 },
111                                 "/etc/rc.local": {
112                                         Path: "/etc/rc.local",
113                                         Mode: 0755,
114                                         Uid:  -1,
115                                         Gid:  -1,
116                                         Data: []byte("#!/bin/sh\n"),
117                                 },
118                                 "/etc/resolv.conf": {
119                                         Path: "/etc/resolv.conf",
120                                         Mode: 0644,
121                                         Uid:  -1,
122                                         Gid:  -1,
123                                         Data: []byte("nameserver ::1\n"),
124                                 },
125                                 "/etc/test": {
126                                         Path: "/etc/test",
127                                         Mode: fs.ModeSymlink | 0777,
128                                         Uid:  -1,
129                                         Gid:  -1,
130                                         Data: []byte("doesnt-exist"),
131                                 },
132                         },
133                         nil,
134                 },
135
136                 {
137                         "templates-invalid-group",
138                         map[string]*safcm.File{
139                                 "/": {
140                                         Path: "/",
141                                         Mode: fs.ModeDir | 0755,
142                                         Uid:  -1,
143                                         Gid:  -1,
144                                 },
145                                 "/etc": {
146                                         Path: "/etc",
147                                         Mode: fs.ModeDir | 0755,
148                                         Uid:  -1,
149                                         Gid:  -1,
150                                 },
151                                 "/etc/motd": {
152                                         Path: "/etc/motd",
153                                         Mode: 0644,
154                                         Uid:  -1,
155                                         Gid:  -1,
156                                         Data: []byte(`
157 {{if .InGroup "invalid-group"}}
158 ...
159 {{end}}
160 `),
161                                 },
162                         },
163                         fmt.Errorf("templates-invalid-group/templates.yaml: template: templates-invalid-group/files/etc/motd:2:5: executing \"templates-invalid-group/files/etc/motd\" at <.InGroup>: error calling InGroup: group \"invalid-group\" does not exist"),
164                 },
165                 {
166                         "templates-invalid-host",
167                         map[string]*safcm.File{
168                                 "/": {
169                                         Path: "/",
170                                         Mode: fs.ModeDir | 0755,
171                                         Uid:  -1,
172                                         Gid:  -1,
173                                 },
174                                 "/etc": {
175                                         Path: "/etc",
176                                         Mode: fs.ModeDir | 0755,
177                                         Uid:  -1,
178                                         Gid:  -1,
179                                 },
180                                 "/etc/motd": {
181                                         Path: "/etc/motd",
182                                         Mode: 0644,
183                                         Uid:  -1,
184                                         Gid:  -1,
185                                         Data: []byte(`
186 {{if .IsHost "invalid-host"}}
187 ...
188 {{end}}
189 `),
190                                 },
191                         },
192                         fmt.Errorf("templates-invalid-host/templates.yaml: template: templates-invalid-host/files/etc/motd:2:5: executing \"templates-invalid-host/files/etc/motd\" at <.IsHost>: error calling IsHost: host \"invalid-host\" does not exist"),
193                 },
194                 {
195                         "templates-invalid-path",
196                         nil,
197                         fmt.Errorf("templates-invalid-path/templates.yaml: \"/etc/motd\" does not exist in files/"),
198                 },
199                 {
200                         "templates-invalid-template",
201                         map[string]*safcm.File{
202                                 "/": {
203                                         Path: "/",
204                                         Mode: fs.ModeDir | 0755,
205                                         Uid:  -1,
206                                         Gid:  -1,
207                                 },
208                                 "/etc": {
209                                         Path: "/etc",
210                                         Mode: fs.ModeDir | 0755,
211                                         Uid:  -1,
212                                         Gid:  -1,
213                                 },
214                                 "/etc/motd": {
215                                         Path: "/etc/motd",
216                                         Mode: 0644,
217                                         Uid:  -1,
218                                         Gid:  -1,
219                                         Data: []byte("{{\n"),
220                                 },
221                         },
222                         fmt.Errorf("templates-invalid-template/templates.yaml: invalid template: templates-invalid-template/files/etc/motd:2: unclosed action started at templates-invalid-template/files/etc/motd:1"),
223                 },
224                 {
225                         "templates-invalid-type",
226                         map[string]*safcm.File{
227                                 "/": {
228                                         Path: "/",
229                                         Mode: fs.ModeDir | 0755,
230                                         Uid:  -1,
231                                         Gid:  -1,
232                                 },
233                                 "/etc": {
234                                         Path: "/etc",
235                                         Mode: fs.ModeDir | 0755,
236                                         Uid:  -1,
237                                         Gid:  -1,
238                                 },
239                                 "/etc/motd": {
240                                         Path: "/etc/motd",
241                                         Mode: 0644,
242                                         Uid:  -1,
243                                         Gid:  -1,
244                                         Data: []byte{},
245                                 },
246                         },
247                         fmt.Errorf("templates-invalid-type/templates.yaml: \"/etc\" is not a regular file"),
248                 },
249         }
250
251         for _, tc := range tests {
252                 t.Run(tc.group, func(t *testing.T) {
253                         // Use LoadFiles() so we work on real data and don't
254                         // make any mistakes generating it
255                         files, err := LoadFiles(tc.group)
256                         if err != nil {
257                                 t.Fatalf("err = %#v, want nil", err)
258                         }
259                         err = LoadTemplates(tc.group, files,
260                                 host, groups, allHosts, allGroups)
261
262                         testutil.AssertEqual(t, "res", files, tc.exp)
263                         testutil.AssertErrorEqual(t, "err", err, tc.expErr)
264                 })
265         }
266 }