add testing

coder · coadler · Jan 13, 2023 · Jan 11, 2023 · Jan 12, 2023 · Jan 12, 2023
commit 404d52278ae0f81c8bb014b090526d3d8954c071
diff --git a/cli/server.go b/cli/server.go
@@ -124,7 +124,7 @@ func Server(vip *viper.Viper, newAPI func(context.Context, *coderd.Options) (*co
 			}
 
 			printLogo(cmd)
-			logger, logCloser, err := makeLogger(cmd, cfg)
+			logger, logCloser, err := buildLogger(cmd, cfg)
 			if err != nil {
 				return xerrors.Errorf("make logger: %w", err)
 			}
@@ -1518,49 +1518,45 @@ func isLocalhost(host string) bool {
 	return host == "localhost" || host == "127.0.0.1" || host == "::1"
 }
 
-func makeLogger(cmd *cobra.Command, cfg *codersdk.DeploymentConfig) (slog.Logger, func(), error) {
+func buildLogger(cmd *cobra.Command, cfg *codersdk.DeploymentConfig) (slog.Logger, func(), error) {
 	var (
 		sinks   = []slog.Sink{}
 		closers = []func() error{}
 	)
 
-	if cfg.Logging.Human.Value != "" {
-		if cfg.Logging.Human.Value == "/dev/stderr" {
-			sinks = append(sinks, sloghuman.Sink(cmd.ErrOrStderr()))
-		} else {
+	addSinkIfProvided := func(sinkFn func(io.Writer) slog.Sink, loc string) error {
+		switch loc {
+		case "":
+
+		case "/dev/stdout":
+			sinks = append(sinks, sinkFn(cmd.OutOrStdout()))
+
+		case "/dev/stderr":
+			sinks = append(sinks, sinkFn(cmd.ErrOrStderr()))
+
+		default:
 			fi, err := os.OpenFile(cfg.Logging.Human.Value, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
 			if err != nil {
-				return slog.Logger{}, nil, xerrors.Errorf("open human log %q: %w", cfg.Logging.Human.Value, err)
+				return xerrors.Errorf("open log file %q: %w", cfg.Logging.Human.Value, err)
 			}
-			closers = append(closers, fi.Close)
-			sinks = append(sinks, sloghuman.Sink(fi))
-		}
-	}
 
-	if cfg.Logging.JSON.Value != "" {
-		if cfg.Logging.JSON.Value == "/dev/stderr" {
-			sinks = append(sinks, slogjson.Sink(cmd.ErrOrStderr()))
-		} else {
-			fi, err := os.OpenFile(cfg.Logging.JSON.Value, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
-			if err != nil {
-				return slog.Logger{}, nil, xerrors.Errorf("open json log %q: %w", cfg.Logging.JSON.Value, err)
-			}
 			closers = append(closers, fi.Close)
-			sinks = append(sinks, slogjson.Sink(fi))
+			sinks = append(sinks, sinkFn(fi))
 		}
+		return nil
 	}
 
-	if cfg.Logging.Stackdriver.Value != "" {
-		if cfg.Logging.JSON.Value == "/dev/stderr" {
-			sinks = append(sinks, slogstackdriver.Sink(cmd.ErrOrStderr()))
-		} else {
-			fi, err := os.OpenFile(cfg.Logging.Stackdriver.Value, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
-			if err != nil {
-				return slog.Logger{}, nil, xerrors.Errorf("open stackdriver log %q: %w", cfg.Logging.Stackdriver.Value, err)
-			}
-			closers = append(closers, fi.Close)
-			sinks = append(sinks, slogstackdriver.Sink(fi))
-		}
+	err := addSinkIfProvided(sloghuman.Sink, cfg.Logging.Human.Value)
+	if err != nil {
+		return slog.Logger{}, nil, xerrors.Errorf("add human sink: %w", err)
+	}
+	err = addSinkIfProvided(slogjson.Sink, cfg.Logging.JSON.Value)
+	if err != nil {
+		return slog.Logger{}, nil, xerrors.Errorf("add json sink: %w", err)
+	}
+	err = addSinkIfProvided(slogstackdriver.Sink, cfg.Logging.Stackdriver.Value)
+	if err != nil {
+		return slog.Logger{}, nil, xerrors.Errorf("add stackdriver sink: %w", err)
 	}
 
 	if cfg.Trace.CaptureLogs.Value {

diff --git a/cli/server_test.go b/cli/server_test.go
@@ -35,6 +35,7 @@ import (
 	"github.com/coder/coder/coderd/database/postgres"
 	"github.com/coder/coder/coderd/telemetry"
 	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/cryptorand"
 	"github.com/coder/coder/pty/ptytest"
 	"github.com/coder/coder/testutil"
 )
@@ -1122,6 +1123,195 @@ func TestServer(t *testing.T) {
 			<-serverErr
 		})
 	})
+
+	t.Run("Logging", func(t *testing.T) {
+		t.Parallel()
+
+		t.Run("CreatesFile", func(t *testing.T) {
+			t.Parallel()
+			ctx, cancelFunc := context.WithCancel(context.Background())
+			defer cancelFunc()
+
+			// fi := os.CreateTemp("/tmp", "coder-logging-test-*")
+			random, err := cryptorand.String(5)
+			require.NoError(t, err)
+			fiName := fmt.Sprint("/tmp/coder-logging-test-", random)
+			defer func() {
+				_ = os.Remove(fiName)
+			}()
+
+			root, _ := clitest.New(t,
+				"server",
+				"--verbose",
+				"--in-memory",
+				"--http-address", ":0",
+				"--access-url", "http://example.com",
+				"--log-human", fiName,
+			)
+			serverErr := make(chan error, 1)
+			go func() {
+				serverErr <- root.ExecuteContext(ctx)
+			}()
+
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fiName)
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			cancelFunc()
+			<-serverErr
+		})
+
+		t.Run("Human", func(t *testing.T) {
+			t.Parallel()
+			ctx, cancelFunc := context.WithCancel(context.Background())
+			defer cancelFunc()
+
+			fi, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi.Name())
+			}()
+
+			root, _ := clitest.New(t,
+				"server",
+				"--verbose",
+				"--in-memory",
+				"--http-address", ":0",
+				"--access-url", "http://example.com",
+				"--log-human", fi.Name(),
+			)
+			serverErr := make(chan error, 1)
+			go func() {
+				serverErr <- root.ExecuteContext(ctx)
+			}()
+
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			cancelFunc()
+			<-serverErr
+		})
+
+		t.Run("JSON", func(t *testing.T) {
+			t.Parallel()
+			ctx, cancelFunc := context.WithCancel(context.Background())
+			defer cancelFunc()
+
+			fi, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi.Name())
+			}()
+
+			root, _ := clitest.New(t,
+				"server",
+				"--verbose",
+				"--in-memory",
+				"--http-address", ":0",
+				"--access-url", "http://example.com",
+				"--log-json", fi.Name(),
+			)
+			serverErr := make(chan error, 1)
+			go func() {
+				serverErr <- root.ExecuteContext(ctx)
+			}()
+
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			cancelFunc()
+			<-serverErr
+		})
+
+		t.Run("Stackdriver", func(t *testing.T) {
+			t.Parallel()
+			ctx, cancelFunc := context.WithCancel(context.Background())
+			defer cancelFunc()
+
+			fi, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi.Name())
+			}()
+
+			root, _ := clitest.New(t,
+				"server",
+				"--verbose",
+				"--in-memory",
+				"--http-address", ":0",
+				"--access-url", "http://example.com",
+				"--log-stackdriver", fi.Name(),
+			)
+			serverErr := make(chan error, 1)
+			go func() {
+				serverErr <- root.ExecuteContext(ctx)
+			}()
+
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			cancelFunc()
+			<-serverErr
+		})
+
+		t.Run("Multiple", func(t *testing.T) {
+			t.Parallel()
+			ctx, cancelFunc := context.WithCancel(context.Background())
+			defer cancelFunc()
+
+			fi1, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi1.Name())
+			}()
+
+			fi2, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi2.Name())
+			}()
+
+			fi3, err := os.CreateTemp("/tmp", "coder-logging-test-*")
+			require.NoError(t, err)
+			defer func() {
+				_ = os.Remove(fi3.Name())
+			}()
+
+			root, _ := clitest.New(t,
+				"server",
+				"--verbose",
+				"--in-memory",
+				"--http-address", ":0",
+				"--access-url", "http://example.com",
+				"--log-human", fi1.Name(),
+				"--log-json", fi2.Name(),
+				"--log-stackdriver", fi3.Name(),
+			)
+			serverErr := make(chan error, 1)
+			go func() {
+				serverErr <- root.ExecuteContext(ctx)
+			}()
+
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi1.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi2.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+			require.Eventually(t, func() bool {
+				stat, err := os.Stat(fi3.Name())
+				return err == nil && stat.Size() > 0
+			}, testutil.IntervalFast, testutil.WaitShort)
+
+			cancelFunc()
+			<-serverErr
+		})
+	})
 }
 
 func generateTLSCertificate(t testing.TB, commonName ...string) (certPath, keyPath string) {