synapsecns/sanguine

package processlog_test

import (
    "bytes"
    "context"
    "fmt"
    "github.com/Flaque/filet"
    "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/core/processlog"
    "io"
    "os"
    "strings"
    "testing"
    "time"
)

// TestWritePrintFunc tests the writePrintFunc function.
func TestWritePrintFunc(t *testing.T) {
    // Create a new pipe for stdout and write some data to it.
    stdOutR, stdOutW := io.Pipe()
    go func() {
        defer func(stdOutW *io.PipeWriter) {
            err := stdOutW.Close()
            assert.Nil(t, err)
        }(stdOutW)
        _, err := stdOutW.Write([]byte("stdout data"))
        if err != nil {
            t.Errorf("unexpected error: %v", err)
        }
    }()

    // Create a new pipe for stderr and write some data to it.
    stdErrR, stdErrW := io.Pipe()
    go func() {
        defer func(stdErrW *io.PipeWriter) {
            err := stdErrW.Close()
            assert.Nil(t, err)
        }(stdErrW)
        _, err := stdErrW.Write([]byte("stderr data"))
        if err != nil {
            t.Errorf("unexpected error: %v", err)
        }
    }()

    // Create a new buffer for the print function.
    var buf bytes.Buffer

    // Create a new context with a timeout.
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    // Call the writePrintFunc function.
    processlog.WritePrintFunc(ctx, func(s []byte) {
        buf.WriteString(fmt.Sprintf("%s ", s))
    }, time.Second, stdOutR, stdErrR)

    // Check that the buffer contains the expected data.
    actual := strings.Split(strings.TrimSuffix(buf.String(), " "), " ")
    expected := strings.Split("stderr datastdout data", " ")

    if len(actual) != len(expected) {
        t.Errorf("expected %q, but got %q", expected, buf.String())
    }
}

type bufCloser struct {
    *bytes.Buffer
}

// Mock.
func (b bufCloser) Close() error {
    return nil
}

// TestPipeSingleOutput tests the pipeSingleOutput function.
func TestPipeSingleOutput(t *testing.T) {
    // Create a new temporary file.
    tmpfile, err := os.CreateTemp("", "example")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    defer func() {
        _ = os.Remove(tmpfile.Name())
    }()

    // Create a new buffer with some data.
    data := "test data"
    buf := bufCloser{bytes.NewBufferString(data)}

    // Call the pipeSingleOutput function.
    err = processlog.PipeSingleOutput(tmpfile, buf)

    // Check that the function returned no error.
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }

    // Check that the file contains the expected data.
    fileData, err := os.ReadFile(tmpfile.Name())
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }
    if string(fileData) != data {
        t.Errorf("expected %q, but got %q", data, string(fileData))
    }
}

// TestPipeCombinedOutput tests the pipeCombinedOutput function.
func TestPipeCombinedOutput(t *testing.T) {
    // Create a new temporary file.
    tmpfile, err := os.CreateTemp("", "example")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    defer func(name string) {
        err := os.Remove(name)
        if err != nil {
            return
        }
    }(tmpfile.Name())

    // Create some mock data.
    data1 := "test data 1"
    data2 := "test data 2"
    data3 := "test data 3"
    buf1 := bufCloser{bytes.NewBufferString(data1)}
    buf2 := bufCloser{bytes.NewBufferString(data2)}
    buf3 := bufCloser{bytes.NewBufferString(data3)}

    // Call the pipeCombinedOutput function with the mock data.
    err = processlog.PipeCombinedOutput(context.Background(), tmpfile, nil, buf1, buf2, buf3)

    // Check that the function returned no error.
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }

    // Check that the file contains the expected data.
    fileData, err := os.ReadFile(tmpfile.Name())
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }
    expectedData := data1 + "\n" + data2 + "\n" + data3 + "\n"
    if len(strings.Split(expectedData, "\n")) != len(strings.Split(string(fileData), "\n")) {
        t.Errorf("expected %q, but got %q", expectedData, string(fileData))
    }
}

// TestStartLogs tests the StartLogs function.
func TestStartLogs(t *testing.T) {
    // Create a new temporary directory.
    tmpdir, err := os.MkdirTemp("", "example")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    defer func(path string) {
        _ = os.RemoveAll(path)
    }(tmpdir)

    // Create some mock data.
    data1 := "test data 1"
    data2 := "test data 2"
    data3 := "test data 3"
    buf1 := bytes.NewBufferString(data1)
    buf2 := bytes.NewBufferString(data2)
    acc := bytes.NewBufferString(data3)

    // Set up the arguments for the StartLogs function.
    logDir := filet.TmpDir(t, tmpdir)
    logFileName := "test"
    logFrequency := 1 * time.Second
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    args := []processlog.StdStreamLogArgsOption{
        processlog.WithStdOut(bufCloser{buf1}),
        processlog.WithStdErr(bufCloser{buf2}),
        processlog.WithLogDir(logDir),
        processlog.WithLogFileName(logFileName),
        processlog.WithLogFrequency(logFrequency),
        processlog.WithAccumulator(acc),
        processlog.WithCtx(ctx),
    }

    // Call the StartLogs function.
    res, err := processlog.StartLogs(args...)
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }

    // Wait for the log files to be written.
    time.Sleep(2 * time.Second)

    // Check that the separate stdout file contains the expected data.
    stdOutData, err := os.ReadFile(res.StdOutFile())
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }
    if string(stdOutData) != data1 {
        t.Errorf("expected %q, but got %q", data1+"\n", string(stdOutData))
    }

    // Check that the separate stderr file contains the expected data.
    stdErrData, err := os.ReadFile(res.StdErrFile())
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }
    if string(stdErrData) != data2 {
        t.Errorf("expected %q, but got %q", data2+"\n", string(stdErrData))
    }

    // Check that the combined log file contains the expected data.
    combinedData, err := os.ReadFile(res.CombinedFile())
    if err != nil {
        t.Errorf("unexpected error: %v", err)
    }
    if !(len(string(combinedData)) >= len(stdErrData)+len(stdOutData)) {
        t.Error("failed to combine")
    }
}