my-log/files/append_test.go

package files

import (
	"context"
	"fmt"
	"os"
	"strings"
	"testing"
	"time"

	"codeberg.org/danjones000/my-log/config"
	"codeberg.org/danjones000/my-log/models"
	"github.com/nalgeon/be"
	"github.com/spf13/viper"
)

func TestAppend(tt *testing.T) {
	tt.Run("success", func(t *testing.T) {
		t.Run("single", appendTestSingle)
		t.Run("two", appendTestTwoEntries)
		t.Run("new_line", appendTestAddNewLine)
		t.Run("no-new-line", appendTestDontAddNewLine)
		t.Run("dot-folder", appendTestDotFolder)
		t.Run("no-dot-folder", appendTestDotFolderNo)
		t.Run("no-ext", appendTestNoExt)
	})
	tt.Run("failure", func(t *testing.T) {
		t.Run("badEntry", appendTestBadEntry)
		t.Run("mkdir-err", appendTestMkdirErr)
		t.Run("append-log-err", appendTestOpenErr)
	})
}

func setupAppendTest(t *testing.T) (string, context.Context) {
	t.Helper()
	dir := t.ArtifactDir()
	v := viper.New()
	v.SetConfigType("toml")
	v.Set("input.path", dir)
	v.Set("input.ext", "log")
	v.Set("input.dotFolder", false)
	ctx := config.AddToContext(t.Context(), v)
	return dir, ctx
}

func appendTestSingle(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	when := time.Now().Local()
	e := models.Entry{
		Title: "Jimmy",
		Date:  when,
		Fields: []models.Meta{
			{Key: "foo", Value: 42},
			{Key: "bar", Value: true},
		},
	}
	l := models.Log{
		Name:    "test",
		Entries: []models.Entry{e},
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, err := os.ReadFile(dir + "/test.log")
	be.Err(t, err, nil)
	st := string(by)
	be.True(t, strings.Contains(st, "Jimmy\n"))
	be.True(t, strings.Contains(st, "\n@foo 42"))
	be.True(t, strings.Contains(st, "\n@bar true"))
}

func appendTestTwoEntries(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	when := time.Now().Local()
	whens := when.Format(models.DateFormat)
	e := []models.Entry{
		{Title: "one", Date: when},
		{Title: "two", Date: when},
	}
	l := models.Log{
		Name:    "test",
		Entries: e,
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, _ := os.ReadFile(dir + "/test.log")
	st := string(by)
	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - one", whens)))
	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - two", whens)))
}

func appendTestAddNewLine(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	os.WriteFile(dir+"/test.log", []byte("foo"), 0644)
	when := time.Now().Local()
	whens := when.Format(models.DateFormat)
	e := []models.Entry{
		{Title: "one", Date: when, Fields: models.Metas{{Key: "id", Value: "jimmy"}}},
	}
	l := models.Log{
		Name:    "test",
		Entries: e,
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, _ := os.ReadFile(dir + "/test.log")
	exp := fmt.Sprintf("foo\n@begin %s - one\n@id jimmy @end\n", whens)
	be.Equal(t, string(by), exp)
}

func appendTestDontAddNewLine(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	os.WriteFile(dir+"/test.log", []byte("foo\n"), 0644)
	when := time.Now().Local()
	whens := when.Format(models.DateFormat)
	e := []models.Entry{
		{Title: "one", Date: when, Fields: models.Metas{{Key: "id", Value: "jimmy"}}},
	}
	l := models.Log{
		Name:    "test",
		Entries: e,
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, _ := os.ReadFile(dir + "/test.log")
	exp := fmt.Sprintf("foo\n@begin %s - one\n@id jimmy @end\n", whens)
	be.Equal(t, string(by), exp)
}

func appendTestBadEntry(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	e := models.Entry{
		Title: "Jimmy",
	}
	l := models.Log{
		Name:    "test",
		Entries: []models.Entry{e},
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, _ := os.ReadFile(dir + "/test.log")
	be.Equal(t, by, []byte{})
}

func appendTestDotFolder(t *testing.T) {
	dir := t.ArtifactDir()
	v := viper.New()
	v.SetConfigType("toml")
	v.Set("input.path", dir)
	v.Set("input.ext", "log")
	v.Set("input.dotFolder", true)
	ctx := config.AddToContext(t.Context(), v)

	e := models.Entry{
		Title: "something",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "sub.test",
		Entries: []models.Entry{e},
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, err := os.ReadFile(dir + "/sub/test.log")
	be.Err(t, err, nil)
	st := string(by)
	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
}

func appendTestDotFolderNo(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	e := models.Entry{
		Title: "another",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "sub.test",
		Entries: []models.Entry{e},
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, err := os.ReadFile(dir + "/sub.test.log")
	be.Err(t, err, nil)
	st := string(by)
	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
}

func appendTestNoExt(t *testing.T) {
	dir := t.ArtifactDir()
	v := viper.New()
	v.SetConfigType("toml")
	v.Set("input.path", dir)
	v.Set("input.ext", "")
	v.Set("input.dotFolder", false)
	ctx := config.AddToContext(t.Context(), v)

	e := models.Entry{
		Title: "baz",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "foobar",
		Entries: []models.Entry{e},
	}
	err := Append(ctx, l)
	be.Err(t, err, nil)
	by, err := os.ReadFile(dir + "/foobar")
	be.Err(t, err, nil)
	st := string(by)
	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
}

func appendTestMkdirErr(t *testing.T) {
	v := viper.New()
	v.SetConfigType("toml")
	v.Set("input.path", "/var/my-logs-test")
	v.Set("input.ext", "log")
	v.Set("input.dotFolder", false)
	ctx := config.AddToContext(t.Context(), v)

	err := Append(ctx, models.Log{})
	be.Err(t, err, "permission denied")
}

func appendTestOpenErr(t *testing.T) {
	dir, ctx := setupAppendTest(t)
	l := models.Log{
		Name: "test-open-err",
	}
	fname := dir + "/test-open-err.log"
	os.MkdirAll(dir, 0750)
	f, _ := os.Create(fname)
	f.Close()
	os.Chmod(fname, 0400)
	err := Append(ctx, l)
	be.Err(t, err, "permission denied")
}