1package testscript
2
3import (
4 "bytes"
5 "context"
6 "flag"
7 "fmt"
8 "io"
9 "net"
10 "net/http"
11 "net/url"
12 "os"
13 "path/filepath"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18
19 "github.com/charmbracelet/keygen"
20 "github.com/charmbracelet/log"
21 "github.com/charmbracelet/soft-serve/server"
22 "github.com/charmbracelet/soft-serve/server/backend"
23 "github.com/charmbracelet/soft-serve/server/config"
24 "github.com/charmbracelet/soft-serve/server/db"
25 "github.com/charmbracelet/soft-serve/server/db/migrate"
26 logr "github.com/charmbracelet/soft-serve/server/log"
27 "github.com/charmbracelet/soft-serve/server/store"
28 "github.com/charmbracelet/soft-serve/server/store/database"
29 "github.com/charmbracelet/soft-serve/server/test"
30 "github.com/rogpeppe/go-internal/testscript"
31 "github.com/spf13/cobra"
32 "golang.org/x/crypto/ssh"
33 _ "modernc.org/sqlite" // sqlite Driver
34)
35
36var update = flag.Bool("update", false, "update script files")
37
38func TestScript(t *testing.T) {
39 flag.Parse()
40 var lock sync.Mutex
41
42 mkkey := func(name string) (string, *keygen.SSHKeyPair) {
43 path := filepath.Join(t.TempDir(), name)
44 pair, err := keygen.New(path, keygen.WithKeyType(keygen.Ed25519), keygen.WithWrite())
45 if err != nil {
46 t.Fatal(err)
47 }
48 return path, pair
49 }
50
51 key, admin1 := mkkey("admin1")
52 _, admin2 := mkkey("admin2")
53 _, user1 := mkkey("user1")
54
55 testscript.Run(t, testscript.Params{
56 Dir: "./testdata/",
57 UpdateScripts: *update,
58 Cmds: map[string]func(ts *testscript.TestScript, neg bool, args []string){
59 "soft": cmdSoft(admin1.Signer()),
60 "usoft": cmdSoft(user1.Signer()),
61 "git": cmdGit(key),
62 "curl": cmdCurl,
63 "mkfile": cmdMkfile,
64 "envfile": cmdEnvfile,
65 "readfile": cmdReadfile,
66 "dos2unix": cmdDos2Unix,
67 },
68 Setup: func(e *testscript.Env) error {
69 data := t.TempDir()
70
71 sshPort := test.RandomPort()
72 sshListen := fmt.Sprintf("localhost:%d", sshPort)
73 gitPort := test.RandomPort()
74 gitListen := fmt.Sprintf("localhost:%d", gitPort)
75 httpPort := test.RandomPort()
76 httpListen := fmt.Sprintf("localhost:%d", httpPort)
77 statsPort := test.RandomPort()
78 statsListen := fmt.Sprintf("localhost:%d", statsPort)
79 serverName := "Test Soft Serve"
80
81 e.Setenv("DATA_PATH", data)
82 e.Setenv("SSH_PORT", fmt.Sprintf("%d", sshPort))
83 e.Setenv("HTTP_PORT", fmt.Sprintf("%d", httpPort))
84 e.Setenv("ADMIN1_AUTHORIZED_KEY", admin1.AuthorizedKey())
85 e.Setenv("ADMIN2_AUTHORIZED_KEY", admin2.AuthorizedKey())
86 e.Setenv("USER1_AUTHORIZED_KEY", user1.AuthorizedKey())
87 e.Setenv("SSH_KNOWN_HOSTS_FILE", filepath.Join(t.TempDir(), "known_hosts"))
88 e.Setenv("SSH_KNOWN_CONFIG_FILE", filepath.Join(t.TempDir(), "config"))
89
90 cfg := config.DefaultConfig()
91 cfg.DataPath = data
92 cfg.Name = serverName
93 cfg.InitialAdminKeys = []string{admin1.AuthorizedKey()}
94 cfg.SSH.ListenAddr = sshListen
95 cfg.SSH.PublicURL = "ssh://" + sshListen
96 cfg.Git.ListenAddr = gitListen
97 cfg.HTTP.ListenAddr = httpListen
98 cfg.HTTP.PublicURL = "http://" + httpListen
99 cfg.Stats.ListenAddr = statsListen
100 cfg.DB.Driver = "sqlite"
101 cfg.LFS.Enabled = true
102 // TODO: run tests with both SSH enabled/disabled
103 cfg.LFS.SSHEnabled = false
104
105 if err := cfg.Validate(); err != nil {
106 return err
107 }
108
109 ctx := config.WithContext(context.Background(), cfg)
110
111 logger, f, err := logr.NewLogger(cfg)
112 if err != nil {
113 log.Errorf("failed to create logger: %v", err)
114 }
115
116 ctx = log.WithContext(ctx, logger)
117 if f != nil {
118 defer f.Close() // nolint: errcheck
119 }
120
121 // TODO: test postgres
122 dbx, err := db.Open(ctx, cfg.DB.Driver, cfg.DB.DataSource)
123 if err != nil {
124 return fmt.Errorf("open database: %w", err)
125 }
126
127 if err := migrate.Migrate(ctx, dbx); err != nil {
128 return fmt.Errorf("migrate database: %w", err)
129 }
130
131 ctx = db.WithContext(ctx, dbx)
132 datastore := database.New(ctx, dbx)
133 ctx = store.WithContext(ctx, datastore)
134 be := backend.New(ctx, cfg, dbx)
135 ctx = backend.WithContext(ctx, be)
136
137 lock.Lock()
138 srv, err := server.NewServer(ctx)
139 if err != nil {
140 lock.Unlock()
141 return err
142 }
143 lock.Unlock()
144
145 go func() {
146 if err := srv.Start(); err != nil {
147 e.T().Fatal(err)
148 }
149 }()
150
151 e.Defer(func() {
152 defer dbx.Close() // nolint: errcheck
153 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
154 defer cancel()
155 lock.Lock()
156 defer lock.Unlock()
157 if err := srv.Shutdown(ctx); err != nil {
158 e.T().Fatal(err)
159 }
160 })
161
162 // wait until the server is up
163 for {
164 conn, _ := net.DialTimeout(
165 "tcp",
166 net.JoinHostPort("localhost", fmt.Sprintf("%d", sshPort)),
167 time.Second,
168 )
169 if conn != nil {
170 conn.Close()
171 break
172 }
173 }
174
175 return nil
176 },
177 })
178}
179
180func cmdSoft(key ssh.Signer) func(ts *testscript.TestScript, neg bool, args []string) {
181 return func(ts *testscript.TestScript, neg bool, args []string) {
182 cli, err := ssh.Dial(
183 "tcp",
184 net.JoinHostPort("localhost", ts.Getenv("SSH_PORT")),
185 &ssh.ClientConfig{
186 User: "admin",
187 Auth: []ssh.AuthMethod{ssh.PublicKeys(key)},
188 HostKeyCallback: ssh.InsecureIgnoreHostKey(),
189 },
190 )
191 ts.Check(err)
192 defer cli.Close()
193
194 sess, err := cli.NewSession()
195 ts.Check(err)
196 defer sess.Close()
197
198 sess.Stdout = ts.Stdout()
199 sess.Stderr = ts.Stderr()
200
201 check(ts, sess.Run(strings.Join(args, " ")), neg)
202 }
203}
204
205// P.S. Windows sucks!
206func cmdDos2Unix(ts *testscript.TestScript, neg bool, args []string) {
207 if neg {
208 ts.Fatalf("unsupported: ! dos2unix")
209 }
210 if len(args) < 1 {
211 ts.Fatalf("usage: dos2unix paths...")
212 }
213 for _, arg := range args {
214 filename := ts.MkAbs(arg)
215 data, err := os.ReadFile(filename)
216 if err != nil {
217 ts.Fatalf("%s: %v", filename, err)
218 }
219
220 // Replace all '\r\n' with '\n'.
221 data = bytes.ReplaceAll(data, []byte{'\r', '\n'}, []byte{'\n'})
222
223 if err := os.WriteFile(filename, data, 0o644); err != nil {
224 ts.Fatalf("%s: %v", filename, err)
225 }
226 }
227}
228
229var sshConfig = `
230Host *
231 UserKnownHostsFile %q
232 StrictHostKeyChecking no
233 IdentityAgent none
234 IdentitiesOnly yes
235 ServerAliveInterval 60
236`
237
238func cmdGit(key string) func(ts *testscript.TestScript, neg bool, args []string) {
239 return func(ts *testscript.TestScript, neg bool, args []string) {
240 ts.Check(os.WriteFile(
241 ts.Getenv("SSH_KNOWN_CONFIG_FILE"),
242 []byte(fmt.Sprintf(sshConfig, ts.Getenv("SSH_KNOWN_HOSTS_FILE"))),
243 0o600,
244 ))
245 sshArgs := []string{
246 "-F", filepath.ToSlash(ts.Getenv("SSH_KNOWN_CONFIG_FILE")),
247 "-i", filepath.ToSlash(key),
248 }
249 ts.Setenv(
250 "GIT_SSH_COMMAND",
251 strings.Join(append([]string{"ssh"}, sshArgs...), " "),
252 )
253 // Disable git prompting for credentials.
254 ts.Setenv("GIT_TERMINAL_PROMPT", "0")
255 args = append([]string{
256 "-c", "user.email=john@example.com",
257 "-c", "user.name=John Doe",
258 }, args...)
259 check(ts, ts.Exec("git", args...), neg)
260 }
261}
262
263func cmdMkfile(ts *testscript.TestScript, neg bool, args []string) {
264 if len(args) < 2 {
265 ts.Fatalf("usage: mkfile path content")
266 }
267 check(ts, os.WriteFile(
268 ts.MkAbs(args[0]),
269 []byte(strings.Join(args[1:], " ")),
270 0o644,
271 ), neg)
272}
273
274func check(ts *testscript.TestScript, err error, neg bool) {
275 if neg && err == nil {
276 ts.Fatalf("expected error, got nil")
277 }
278 if !neg {
279 ts.Check(err)
280 }
281}
282
283func cmdReadfile(ts *testscript.TestScript, neg bool, args []string) {
284 ts.Stdout().Write([]byte(ts.ReadFile(args[0])))
285}
286
287func cmdEnvfile(ts *testscript.TestScript, neg bool, args []string) {
288 if len(args) < 1 {
289 ts.Fatalf("usage: envfile key=file...")
290 }
291
292 for _, arg := range args {
293 parts := strings.SplitN(arg, "=", 2)
294 if len(parts) != 2 {
295 ts.Fatalf("usage: envfile key=file...")
296 }
297 key := parts[0]
298 file := parts[1]
299 ts.Setenv(key, strings.TrimSpace(ts.ReadFile(file)))
300 }
301}
302
303func cmdCurl(ts *testscript.TestScript, neg bool, args []string) {
304 var verbose bool
305 var headers []string
306 var data string
307 method := http.MethodGet
308
309 cmd := &cobra.Command{
310 Use: "curl",
311 Args: cobra.MinimumNArgs(1),
312 RunE: func(cmd *cobra.Command, args []string) error {
313 url, err := url.Parse(args[0])
314 if err != nil {
315 return err
316 }
317
318 req, err := http.NewRequest(method, url.String(), nil)
319 if err != nil {
320 return err
321 }
322
323 if data != "" {
324 req.Body = io.NopCloser(strings.NewReader(data))
325 }
326
327 if verbose {
328 fmt.Fprintf(cmd.ErrOrStderr(), "< %s %s\n", req.Method, url.String())
329 }
330
331 for _, header := range headers {
332 parts := strings.SplitN(header, ":", 2)
333 if len(parts) != 2 {
334 return fmt.Errorf("invalid header: %s", header)
335 }
336 req.Header.Add(strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]))
337 }
338
339 if userInfo := url.User; userInfo != nil {
340 password, _ := userInfo.Password()
341 req.SetBasicAuth(userInfo.Username(), password)
342 }
343
344 if verbose {
345 for key, values := range req.Header {
346 for _, value := range values {
347 fmt.Fprintf(cmd.ErrOrStderr(), "< %s: %s\n", key, value)
348 }
349 }
350 }
351
352 resp, err := http.DefaultClient.Do(req)
353 if err != nil {
354 return err
355 }
356
357 if verbose {
358 fmt.Fprintf(ts.Stderr(), "> %s\n", resp.Status)
359 for key, values := range resp.Header {
360 for _, value := range values {
361 fmt.Fprintf(cmd.ErrOrStderr(), "> %s: %s\n", key, value)
362 }
363 }
364 }
365
366 defer resp.Body.Close()
367 buf, err := io.ReadAll(resp.Body)
368 if err != nil {
369 return err
370 }
371
372 cmd.Print(string(buf))
373
374 return nil
375 },
376 }
377
378 cmd.SetArgs(args)
379 cmd.SetOut(ts.Stdout())
380 cmd.SetErr(ts.Stderr())
381
382 cmd.Flags().BoolVarP(&verbose, "verbose", "v", verbose, "verbose")
383 cmd.Flags().StringArrayVarP(&headers, "header", "H", nil, "HTTP header")
384 cmd.Flags().StringVarP(&method, "request", "X", method, "HTTP method")
385 cmd.Flags().StringVarP(&data, "data", "d", data, "HTTP data")
386
387 check(ts, cmd.Execute(), neg)
388}