my-log/files/append_test.go

package files

import (
	"fmt"
	"os"
	"testing"
	"time"

	"codeberg.org/danjones000/my-log/config"
	"codeberg.org/danjones000/my-log/models"
	"github.com/stretchr/testify/suite"
)

func TestAppend(t *testing.T) {
	suite.Run(t, new(AppendTestSuite))
}

type AppendTestSuite struct {
	suite.Suite
	dir string
}

func (s *AppendTestSuite) SetupSuite() {
	s.dir, _ = os.MkdirTemp("", "append-test")
	config.Overrides["input.path"] = s.dir
	config.Overrides["input.ext"] = "log"
}

func (s *AppendTestSuite) TearDownSuite() {
	os.RemoveAll(s.dir)
	delete(config.Overrides, "input.path")
	delete(config.Overrides, "input.ext")
}

func (s *AppendTestSuite) TestSuccess() {
	defer os.Remove(s.dir + "/test.log")
	when := time.Now().Local()
	e := models.Entry{
		Title: "Jimmy",
		Date:  when,
		Fields: []models.Meta{
			{"foo", 42},
			{"bar", true},
		},
	}
	l := models.Log{
		Name:    "test",
		Entries: []models.Entry{e},
	}
	err := Append(l)
	s.Require().NoError(err)
	s.Require().FileExists(s.dir + "/test.log")
	by, err := os.ReadFile(s.dir + "/test.log")
	st := string(by)
	s.Require().NoError(err)
	s.Assert().Contains(st, "Jimmy\n")
	s.Assert().Contains(st, "\n@foo 42")
	s.Assert().Contains(st, "\n@bar true")
}

func (s *AppendTestSuite) TestTwoEntries() {
	defer os.Remove(s.dir + "/test.log")
	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(l)
	s.Assert().NoError(err)
	s.Require().FileExists(s.dir + "/test.log")
	by, _ := os.ReadFile(s.dir + "/test.log")
	exp := fmt.Sprintf("@begin %s - one @end\n@begin %s - two @end\n", whens, whens)
	s.Assert().Equal(exp, string(by))
}

func (s *AppendTestSuite) TestAddNewLine() {
	defer os.Remove(s.dir + "/test.log")
	os.WriteFile(s.dir+"/test.log", []byte("foo"), 0644)
	when := time.Now().Local()
	whens := when.Format(models.DateFormat)
	e := []models.Entry{
		{Title: "one", Date: when},
	}
	l := models.Log{
		Name:    "test",
		Entries: e,
	}
	err := Append(l)
	s.Assert().NoError(err)
	s.Require().FileExists(s.dir + "/test.log")
	by, _ := os.ReadFile(s.dir + "/test.log")
	exp := fmt.Sprintf("foo\n@begin %s - one @end\n", whens)
	s.Assert().Equal(exp, string(by))
}

func (s *AppendTestSuite) TestDontAddNewLine() {
	defer os.Remove(s.dir + "/test.log")
	os.WriteFile(s.dir+"/test.log", []byte("foo\n"), 0644)
	when := time.Now().Local()
	whens := when.Format(models.DateFormat)
	e := []models.Entry{
		{Title: "one", Date: when},
	}
	l := models.Log{
		Name:    "test",
		Entries: e,
	}
	err := Append(l)
	s.Assert().NoError(err)
	s.Require().FileExists(s.dir + "/test.log")
	by, _ := os.ReadFile(s.dir + "/test.log")
	exp := fmt.Sprintf("foo\n@begin %s - one @end\n", whens)
	s.Assert().Equal(exp, string(by))
}

func (s *AppendTestSuite) TestFailEntry() {
	defer os.Remove(s.dir + "/test.log")
	e := models.Entry{
		Title: "Jimmy",
	}
	l := models.Log{
		Name:    "test",
		Entries: []models.Entry{e},
	}
	err := Append(l)
	s.Assert().NoError(err)
	s.Require().FileExists(s.dir + "/test.log")
	by, _ := os.ReadFile(s.dir + "/test.log")
	s.Assert().Equal([]byte{}, by)
}

func (s *AppendTestSuite) TestDotFolder() {
	config.Overrides["input.dotFolder"] = "true"
	e := models.Entry{
		Title: "something",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "sub.test",
		Entries: []models.Entry{e},
	}
	err := Append(l)
	s.Require().NoError(err)
	s.Require().FileExists(s.dir + "/sub/test.log")
	by, err := os.ReadFile(s.dir + "/sub/test.log")
	st := string(by)
	s.Require().NoError(err)
	s.Assert().Contains(st, "something @end")
}

func (s *AppendTestSuite) TestDotFolderNo() {
	config.Overrides["input.dotFolder"] = "false"
	e := models.Entry{
		Title: "another",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "sub.test",
		Entries: []models.Entry{e},
	}
	err := Append(l)
	s.Require().NoError(err)
	s.Require().FileExists(s.dir + "/sub.test.log")
	by, err := os.ReadFile(s.dir + "/sub.test.log")
	st := string(by)
	s.Require().NoError(err)
	s.Assert().Contains(st, "another @end")
}

func (s *AppendTestSuite) TestNoExt() {
	config.Overrides["input.ext"] = ""
	defer func() {
		config.Overrides["input.ext"] = "log"
	}()
	e := models.Entry{
		Title: "baz",
		Date:  time.Now(),
	}
	l := models.Log{
		Name:    "foobar",
		Entries: []models.Entry{e},
	}
	err := Append(l)
	s.Require().NoError(err)
	s.Require().FileExists(s.dir + "/foobar")
	by, err := os.ReadFile(s.dir + "/foobar")
	st := string(by)
	s.Require().NoError(err)
	s.Assert().Contains(st, "baz @end")
}

func (s *AppendTestSuite) TestConfLoadErr() {
	currConf := config.ConfigPath
	tmp, _ := os.CreateTemp("", "app-conf-*.toml")
	fname := tmp.Name()
	defer tmp.Close()
	defer os.Remove(fname)
	fmt.Fprintln(tmp, `{"not":"toml"}`)
	config.ConfigPath = fname
	defer func(path string) {
		config.ConfigPath = path
	}(currConf)
	err := Append(models.Log{})
	s.Assert().ErrorContains(err, "toml")
}

func (s *AppendTestSuite) TestMkdirErr() {
	// Don't run this test as root
	config.Overrides["input.path"] = "/root/my-logs-test"
	defer func(path string) {
		config.Overrides["input.path"] = path
	}(s.dir)
	err := Append(models.Log{})
	s.Assert().ErrorContains(err, "permission denied")
}

func (s *AppendTestSuite) TestOpenErr() {
	l := models.Log{
		Name: "test-open-err",
	}
	fname := s.dir + "/test-open-err.log"
	os.MkdirAll(s.dir, 0750)
	f, _ := os.Create(fname)
	f.Close()
	os.Chmod(fname, 0400) // read only
	err := Append(l)
	s.Assert().ErrorContains(err, "permission denied")
}