AGENTS.md

@@ -15,7 +15,7 @@
 - **Types**: Use explicit types (e.g., `int64`, `float64`). Convert numbers appropriately when unmarshaling JSON
 - **Naming**: PascalCase for exported, camelCase for unexported. Use descriptive names
 - **Error handling**: Return wrapped errors with context. Define custom errors in models/errors.go. Use `ErrorIs` for error checking
-- **Testing**: Use github.com/nalgeon/be. Table-driven tests with helper functions. Test both marshal/unmarshal for encoding types
+- **Testing**: Use testify/assert. Table-driven tests with helper functions. Test both marshal/unmarshal for encoding types
 - **Concurrency**: Use channels and goroutines with WaitGroups for parallel processing (see entry.go patterns)
 - **Comments**: Include license header on cmd files. Document exported functions and types
 

CHANGELOG.md

@@ -1,12 +1,5 @@
 # Changelog
 
-## [0.0.11] - 2026-02-13
-
-- ✨ Add support for mixed-level nested keys with dot/blank handling
-- ✨ Refactor append_test to use standalone test functions
-- ✨ Migrate from testify to nalgeon/be testing library
-- ✨ Add bep.JSON helper for JSON assertion in tests
-
 ## [0.0.10] - 2026-02-10
 
 - ✨ Implement full support for nested fields in Meta and Entry marshalling

config/default_test.go

@@ -5,13 +5,14 @@ import (
 	fp "path/filepath"
 	"testing"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDefaultConfig(t *testing.T) {
 	home, _ := os.UserHomeDir()
 	inDir := fp.Join(home, "my-log")
 	c, err := DefaultConfig()
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, c.Input.Path, inDir)
+	assert.Equal(t, inDir, c.Input.Path)
 }

config/load_test.go

@@ -5,7 +5,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLoad(t *testing.T) {
@@ -15,8 +16,8 @@ func TestLoad(t *testing.T) {
 	fmt.Fprint(f, `[input]
 ext = "log"`)
 	c, err := Load()
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, c.Input.Ext, "log")
+	assert.Equal(t, "log", c.Input.Ext)
 }
 
 func TestLoadBadFile(t *testing.T) {
@@ -25,15 +26,15 @@ func TestLoadBadFile(t *testing.T) {
 	defer f.Close()
 	fmt.Fprint(f, `{"not":"toml"}`)
 	_, err := Load()
-	be.Err(t, err)
+	assert.Error(t, err)
 }
 
 func TestLoadIgnoreMissingFile(t *testing.T) {
 	def, _ := DefaultConfig()
 	ConfigPath = "/not/a/real/file"
 	c, err := Load()
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, c, def)
+	assert.Equal(t, def, c)
 }
 
 func TestOverride(t *testing.T) {
@@ -42,30 +43,30 @@ func TestOverride(t *testing.T) {
 		"input.ext":  "~",
 	}
 	c, err := Load()
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, c.Input.Path, Overrides["input.path"])
+	assert.Equal(t, Overrides["input.path"], c.Input.Path)
-	be.Equal(t, c.Input.Ext, "txt")
+	assert.Equal(t, "txt", c.Input.Ext)
 }
 
 func TestOverrideJson(t *testing.T) {
 	Overrides = map[string]string{"input.ext": `{"a":"b"}`}
 	c, err := Load()
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, c.Input.Ext, "txt")
+	assert.Equal(t, "txt", c.Input.Ext)
 }
 
 func TestTimeParse(t *testing.T) {
 	Overrides = map[string]string{"input.ext": "now"}
 	c, err := Load()
-	be.Err(t, err, "incompatible types: TOML value has type time.Time; destination has type string")
+	assert.ErrorContains(t, err, "incompatible types: TOML value has type time.Time; destination has type string")
-	be.Equal(t, c.Input.Ext, "txt")
+	assert.Equal(t, "txt", c.Input.Ext)
 }
 
 func TestStdoutMissing(t *testing.T) {
 	var oo Outputs = map[string]Output{}
 	std, en := oo.Stdout()
-	be.True(t, !en)
+	assert.False(t, en)
-	be.Equal(t, std, Stdout{})
+	assert.Equal(t, Stdout{}, std)
 }
 
 func TestStdoutLoad(t *testing.T) {
@@ -75,8 +76,8 @@ func TestStdoutLoad(t *testing.T) {
 	defer os.Unsetenv("LOG_STDOUT_ENABLED")
 	c, _ := Load()
 	std, en := c.Outputs.Stdout()
-	be.True(t, en)
+	assert.True(t, en)
-	be.Equal(t, std.Format, "json")
+	assert.Equal(t, "json", std.Format)
 }
 
 func TestFormatJson(t *testing.T) {
@@ -85,9 +86,9 @@ func TestFormatJson(t *testing.T) {
 	}
 
 	js := ff.Json()
-	be.True(t, js.PrettyPrint)
+	assert.True(t, js.PrettyPrint)
 
 	ff = Formatters{}
 	js = ff.Json()
-	be.True(t, !js.PrettyPrint)
+	assert.False(t, js.PrettyPrint)
 }

files/append_test.go

@@ -3,47 +3,37 @@ package files
 import (
 	"fmt"
 	"os"
-	"strings"
 	"testing"
 	"time"
 
 	"codeberg.org/danjones000/my-log/config"
 	"codeberg.org/danjones000/my-log/models"
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/suite"
 )
 
-func TestAppend(tt *testing.T) {
+func TestAppend(t *testing.T) {
-	tt.Run("success", func(t *testing.T) {
+	suite.Run(t, new(AppendTestSuite))
-		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("load-err", appendTestConfLoadErr)
-		t.Run("mkdir-err", appendTestMkdirErr)
-		t.Run("append-log-err", appendTestOpenErr)
-	})
 }
 
-func setupAppendTest(t *testing.T) string {
+type AppendTestSuite struct {
-	t.Helper()
+	suite.Suite
-	dir := t.ArtifactDir()
+	dir string
-	config.Overrides["input.path"] = dir
+}
+
+func (s *AppendTestSuite) SetupSuite() {
+	s.dir, _ = os.MkdirTemp("", "append-test")
+	config.Overrides["input.path"] = s.dir
 	config.Overrides["input.ext"] = "log"
-	t.Cleanup(func() {
-		delete(config.Overrides, "input.path")
-		delete(config.Overrides, "input.ext")
-	})
-	return dir
 }
 
-func appendTestSingle(t *testing.T) {
+func (s *AppendTestSuite) TearDownSuite() {
-	dir := setupAppendTest(t)
+	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",
@@ -58,17 +48,18 @@ func appendTestSingle(t *testing.T) {
 		Entries: []models.Entry{e},
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Require().NoError(err)
-	by, err := os.ReadFile(dir + "/test.log")
+	s.Require().FileExists(s.dir + "/test.log")
-	be.Err(t, err, nil)
+	by, err := os.ReadFile(s.dir + "/test.log")
 	st := string(by)
-	be.True(t, strings.Contains(st, "Jimmy\n"))
+	s.Require().NoError(err)
-	be.True(t, strings.Contains(st, "\n@foo 42"))
+	s.Assert().Contains(st, "Jimmy\n")
-	be.True(t, strings.Contains(st, "\n@bar true"))
+	s.Assert().Contains(st, "\n@foo 42")
+	s.Assert().Contains(st, "\n@bar true")
 }
 
-func appendTestTwoEntries(t *testing.T) {
+func (s *AppendTestSuite) TestTwoEntries() {
-	dir := setupAppendTest(t)
+	defer os.Remove(s.dir + "/test.log")
 	when := time.Now().Local()
 	whens := when.Format(models.DateFormat)
 	e := []models.Entry{
@@ -80,16 +71,17 @@ func appendTestTwoEntries(t *testing.T) {
 		Entries: e,
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Assert().NoError(err)
-	by, _ := os.ReadFile(dir + "/test.log")
+	s.Require().FileExists(s.dir + "/test.log")
+	by, _ := os.ReadFile(s.dir + "/test.log")
 	st := string(by)
-	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - one", whens)))
+	s.Assert().Contains(st, fmt.Sprintf("@begin %s - one", whens))
-	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - two", whens)))
+	s.Assert().Contains(st, fmt.Sprintf("@begin %s - two", whens))
 }
 
-func appendTestAddNewLine(t *testing.T) {
+func (s *AppendTestSuite) TestAddNewLine() {
-	dir := setupAppendTest(t)
+	defer os.Remove(s.dir + "/test.log")
-	os.WriteFile(dir+"/test.log", []byte("foo"), 0644)
+	os.WriteFile(s.dir+"/test.log", []byte("foo"), 0644)
 	when := time.Now().Local()
 	whens := when.Format(models.DateFormat)
 	e := []models.Entry{
@@ -100,15 +92,16 @@ func appendTestAddNewLine(t *testing.T) {
 		Entries: e,
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Assert().NoError(err)
-	by, _ := os.ReadFile(dir + "/test.log")
+	s.Require().FileExists(s.dir + "/test.log")
+	by, _ := os.ReadFile(s.dir + "/test.log")
 	exp := fmt.Sprintf("foo\n@begin %s - one\n@id jimmy @end\n", whens)
-	be.Equal(t, string(by), exp)
+	s.Assert().Equal(exp, string(by))
 }
 
-func appendTestDontAddNewLine(t *testing.T) {
+func (s *AppendTestSuite) TestDontAddNewLine() {
-	dir := setupAppendTest(t)
+	defer os.Remove(s.dir + "/test.log")
-	os.WriteFile(dir+"/test.log", []byte("foo\n"), 0644)
+	os.WriteFile(s.dir+"/test.log", []byte("foo\n"), 0644)
 	when := time.Now().Local()
 	whens := when.Format(models.DateFormat)
 	e := []models.Entry{
@@ -119,14 +112,15 @@ func appendTestDontAddNewLine(t *testing.T) {
 		Entries: e,
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Assert().NoError(err)
-	by, _ := os.ReadFile(dir + "/test.log")
+	s.Require().FileExists(s.dir + "/test.log")
+	by, _ := os.ReadFile(s.dir + "/test.log")
 	exp := fmt.Sprintf("foo\n@begin %s - one\n@id jimmy @end\n", whens)
-	be.Equal(t, string(by), exp)
+	s.Assert().Equal(exp, string(by))
 }
 
-func appendTestBadEntry(t *testing.T) {
+func (s *AppendTestSuite) TestFailEntry() {
-	dir := setupAppendTest(t)
+	defer os.Remove(s.dir + "/test.log")
 	e := models.Entry{
 		Title: "Jimmy",
 	}
@@ -135,18 +129,14 @@ func appendTestBadEntry(t *testing.T) {
 		Entries: []models.Entry{e},
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Assert().NoError(err)
-	by, _ := os.ReadFile(dir + "/test.log")
+	s.Require().FileExists(s.dir + "/test.log")
-	be.Equal(t, by, []byte{})
+	by, _ := os.ReadFile(s.dir + "/test.log")
+	s.Assert().Equal([]byte{}, by)
 }
 
-func appendTestDotFolder(t *testing.T) {
+func (s *AppendTestSuite) TestDotFolder() {
 	config.Overrides["input.dotFolder"] = "true"
-	t.Cleanup(func() {
-		delete(config.Overrides, "input.dotFolder")
-	})
-
-	dir := setupAppendTest(t)
 	e := models.Entry{
 		Title: "something",
 		Date:  time.Now(),
@@ -156,20 +146,16 @@ func appendTestDotFolder(t *testing.T) {
 		Entries: []models.Entry{e},
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Require().NoError(err)
-	by, err := os.ReadFile(dir + "/sub/test.log")
+	s.Require().FileExists(s.dir + "/sub/test.log")
-	be.Err(t, err, nil)
+	by, err := os.ReadFile(s.dir + "/sub/test.log")
 	st := string(by)
-	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
+	s.Require().NoError(err)
+	s.Assert().Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title))
 }
 
-func appendTestDotFolderNo(t *testing.T) {
+func (s *AppendTestSuite) TestDotFolderNo() {
 	config.Overrides["input.dotFolder"] = "false"
-	t.Cleanup(func() {
-		delete(config.Overrides, "input.dotFolder")
-	})
-
-	dir := setupAppendTest(t)
 	e := models.Entry{
 		Title: "another",
 		Date:  time.Now(),
@@ -179,20 +165,19 @@ func appendTestDotFolderNo(t *testing.T) {
 		Entries: []models.Entry{e},
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Require().NoError(err)
-	by, err := os.ReadFile(dir + "/sub.test.log")
+	s.Require().FileExists(s.dir + "/sub.test.log")
-	be.Err(t, err, nil)
+	by, err := os.ReadFile(s.dir + "/sub.test.log")
 	st := string(by)
-	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
+	s.Require().NoError(err)
+	s.Assert().Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title))
 }
 
-func appendTestNoExt(t *testing.T) {
+func (s *AppendTestSuite) TestNoExt() {
-	dir := setupAppendTest(t)
 	config.Overrides["input.ext"] = ""
-	t.Cleanup(func() {
+	defer func() {
 		config.Overrides["input.ext"] = "log"
-	})
+	}()
-
 	e := models.Entry{
 		Title: "baz",
 		Date:  time.Now(),
@@ -202,48 +187,48 @@ func appendTestNoExt(t *testing.T) {
 		Entries: []models.Entry{e},
 	}
 	err := Append(l)
-	be.Err(t, err, nil)
+	s.Require().NoError(err)
-	by, err := os.ReadFile(dir + "/foobar")
+	s.Require().FileExists(s.dir + "/foobar")
-	be.Err(t, err, nil)
+	by, err := os.ReadFile(s.dir + "/foobar")
 	st := string(by)
-	be.True(t, strings.Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title)))
+	s.Require().NoError(err)
+	s.Assert().Contains(st, fmt.Sprintf("@begin %s - %s", e.Date.Format(models.DateFormat), e.Title))
 }
 
-func appendTestConfLoadErr(t *testing.T) {
+func (s *AppendTestSuite) TestConfLoadErr() {
-	dir := t.ArtifactDir()
-
 	currConf := config.ConfigPath
-	tmp, _ := os.CreateTemp(dir, "app-conf-*.toml")
+	tmp, _ := os.CreateTemp("", "app-conf-*.toml")
 	fname := tmp.Name()
-	t.Cleanup(func() { tmp.Close() })
+	defer tmp.Close()
-	t.Cleanup(func() { os.Remove(fname) })
+	defer os.Remove(fname)
 	fmt.Fprintln(tmp, `{"not":"toml"}`)
 	config.ConfigPath = fname
-	t.Cleanup(func() { config.ConfigPath = currConf })
+	defer func(path string) {
-
+		config.ConfigPath = path
+	}(currConf)
 	err := Append(models.Log{})
-	be.Err(t, err, "toml")
+	s.Assert().ErrorContains(err, "toml")
 }
 
-func appendTestMkdirErr(t *testing.T) {
+func (s *AppendTestSuite) TestMkdirErr() {
 	// Don't run this test as root
 	config.Overrides["input.path"] = "/var/my-logs-test"
-	t.Cleanup(func() { delete(config.Overrides, "input.path") })
+	defer func(path string) {
-
+		config.Overrides["input.path"] = path
+	}(s.dir)
 	err := Append(models.Log{})
-	be.Err(t, err, "permission denied")
+	s.Assert().ErrorContains(err, "permission denied")
 }
 
-func appendTestOpenErr(t *testing.T) {
+func (s *AppendTestSuite) TestOpenErr() {
-	dir := setupAppendTest(t)
 	l := models.Log{
 		Name: "test-open-err",
 	}
-	fname := dir + "/test-open-err.log"
+	fname := s.dir + "/test-open-err.log"
-	os.MkdirAll(dir, 0750)
+	os.MkdirAll(s.dir, 0750)
 	f, _ := os.Create(fname)
 	f.Close()
-	os.Chmod(fname, 0400)
+	os.Chmod(fname, 0400) // read only
 	err := Append(l)
-	be.Err(t, err, "permission denied")
+	s.Assert().ErrorContains(err, "permission denied")
 }

formatters/json_test.go

@@ -5,14 +5,13 @@ import (
 	"testing"
 	"time"
 
-	"codeberg.org/danjones000/my-log/internal/testutil/bep"
 	"codeberg.org/danjones000/my-log/models"
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestJsonName(t *testing.T) {
 	f, _ := New("json")
-	be.Equal(t, f.Name(), "json")
+	assert.Equal(t, "json", f.Name())
 }
 
 func TestJsonMeta(t *testing.T) {
@@ -20,8 +19,8 @@ func TestJsonMeta(t *testing.T) {
 	m := models.Meta{"foo", 42}
 	exp := `{"foo":42}`
 	o, err := f.Meta(m)
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	bep.JSON(t, o, []byte(exp))
+	assert.JSONEq(t, exp, string(o))
 }
 
 func TestJsonEntry(t *testing.T) {
@@ -35,8 +34,8 @@ func TestJsonEntry(t *testing.T) {
 	}
 	exp := fmt.Sprintf(`{"title":"%s","date":"%s","foo":42}`, e.Title, when.Format(time.RFC3339))
 	o, err := f.Entry(e)
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	bep.JSON(t, o, []byte(exp))
+	assert.JSONEq(t, exp, string(o))
 }
 
 func TestJsonLog(t *testing.T) {
@@ -51,24 +50,24 @@ func TestJsonLog(t *testing.T) {
 	l := models.Log{"stuff", []models.Entry{e}}
 	exp := fmt.Sprintf(`{"%s":[{"title":"%s","date":"%s","foo":42}]}`, l.Name, e.Title, when.Format(time.RFC3339))
 	o, err := f.Log(l)
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	bep.JSON(t, o, []byte(exp))
+	assert.JSONEq(t, exp, string(o))
 }
 
 func TestJsonNoLogs(t *testing.T) {
 	f, _ := New("json")
 	o, err := f.Logs([]models.Log{})
 	var exp []byte
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, o, exp)
+	assert.Equal(t, exp, o)
 }
 
 func TestJsonErr(t *testing.T) {
 	f, _ := New("json")
 	o, err := f.Meta(models.Meta{"foo", make(chan bool)})
 	var exp []byte
-	be.Err(t, err)
+	assert.Error(t, err)
-	be.Equal(t, o, exp)
+	assert.Equal(t, exp, o)
 }
 
 func TestJsonPretty(t *testing.T) {
@@ -77,6 +76,6 @@ func TestJsonPretty(t *testing.T) {
 	exp := `{
 	"foo": 42
 }`
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, string(o), exp)
+	assert.Equal(t, exp, string(o))
 }

formatters/new_test.go

@@ -3,24 +3,20 @@ package formatters
 import (
 	"fmt"
 	"os"
-	"slices"
 	"testing"
 
 	"codeberg.org/danjones000/my-log/config"
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestKinds(t *testing.T) {
-	kinds := Kinds()
+	assert.ElementsMatch(t, []string{"plain", "json", "zero"}, Kinds())
-	for _, kind := range []string{"plain", "json", "zero"} {
-		be.True(t, slices.Contains(kinds, kind))
-	}
 }
 
 func TestNewUnsupported(t *testing.T) {
 	f, err := New("nope")
-	be.Equal(t, f, nil)
+	assert.Nil(t, f)
-	be.Err(t, err)
+	assert.Error(t, err)
 }
 
 func TestNewCantGetConfig(t *testing.T) {
@@ -34,16 +30,16 @@ func TestNewCantGetConfig(t *testing.T) {
 
 	fmt.Fprint(f, `{"not":"toml"}`)
 	form, err := New("plain")
-	be.Equal(t, form, nil)
+	assert.Nil(t, form)
-	be.Err(t, err)
+	assert.Error(t, err)
 
 	form, err = Preferred()
-	be.Equal(t, form, nil)
+	assert.Nil(t, form)
-	be.Err(t, err)
+	assert.Error(t, err)
 }
 
 func TestPreferred(t *testing.T) {
 	form, err := Preferred()
-	be.Err(t, err, nil)
+	assert.NotNil(t, form)
-	be.True(t, form != nil)
+	assert.NoError(t, err)
 }

formatters/null_test.go

@@ -5,41 +5,41 @@ import (
 	"time"
 
 	"codeberg.org/danjones000/my-log/models"
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
 )
 
 var empty []byte
 
 func TestNullName(t *testing.T) {
 	f, err := New("zero")
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, f.Name(), "zero")
+	assert.Equal(t, "zero", f.Name())
 }
 
 func TestNullMeta(t *testing.T) {
 	f, _ := New("zero")
 	o, err := f.Meta(models.Meta{"foo", 42})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, o, empty)
+	assert.Equal(t, empty, o)
 }
 
 func TestNullEntry(t *testing.T) {
 	f, _ := New("zero")
 	o, err := f.Entry(models.Entry{"title", time.Now(), models.Metas{}})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, o, empty)
+	assert.Equal(t, empty, o)
 }
 
 func TestNullLog(t *testing.T) {
 	f, _ := New("zero")
 	o, err := f.Log(models.Log{"jim", []models.Entry{{"title", time.Now(), models.Metas{}}}})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, o, empty)
+	assert.Equal(t, empty, o)
 }
 
 func TestNullLogs(t *testing.T) {
 	f, _ := New("zero")
 	o, err := f.Logs([]models.Log{{"jim", []models.Entry{{"title", time.Now(), models.Metas{}}}}})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, o, empty)
+	assert.Equal(t, empty, o)
 }

formatters/plain_test.go

@@ -9,7 +9,8 @@ import (
 
 	"codeberg.org/danjones000/my-log/models"
 	"codeberg.org/danjones000/my-log/tools"
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestPlainLogs(t *testing.T) {
@@ -30,101 +31,101 @@ func TestPlainLogs(t *testing.T) {
 	logs := []models.Log{l, l2}
 
 	f, err := New("plain")
-	be.Err(t, err, nil)
+	require.NoError(t, err)
 
 	out, err := f.Logs(logs)
-	be.Err(t, err, nil)
+	require.NoError(t, err)
 
 	read := bytes.NewReader(out)
 	scan := bufio.NewScanner(read)
 
 	scan.Scan()
 	line := scan.Text()
-	be.Equal(t, line, l.Name)
+	assert.Equal(t, l.Name, line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "#######")
+	assert.Equal(t, "#######", line)
 
 	scan.Scan()
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Title: "+e[0].Title)
+	assert.Equal(t, "Title: "+e[0].Title, line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Date: "+e[0].Date.Format(tools.DateFormat))
+	assert.Equal(t, "Date: "+e[0].Date.Format(tools.DateFormat), line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "foo: bar")
+	assert.Equal(t, "foo: bar", line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "baz: 42")
+	assert.Equal(t, "baz: 42", line)
 
 	scan.Scan()
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Title: "+e[1].Title)
+	assert.Equal(t, "Title: "+e[1].Title, line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Date: "+e[1].Date.Format(tools.DateFormat))
+	assert.Equal(t, "Date: "+e[1].Date.Format(tools.DateFormat), line)
 
 	scan.Scan()
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, l2.Name)
+	assert.Equal(t, l2.Name, line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "#######")
+	assert.Equal(t, "#######", line)
 
 	scan.Scan()
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Title: "+e2.Title)
+	assert.Equal(t, "Title: "+e2.Title, line)
 
 	scan.Scan()
 	line = scan.Text()
-	be.Equal(t, line, "Date: "+e2.Date.Format(tools.DateFormat))
+	assert.Equal(t, "Date: "+e2.Date.Format(tools.DateFormat), line)
 
 	more := scan.Scan()
-	be.True(t, !more)
+	assert.False(t, more)
 }
 
 func TestPlainName(t *testing.T) {
 	f, _ := New("plain")
-	be.Equal(t, f.Name(), "plain")
+	assert.Equal(t, "plain", f.Name())
 }
 
 func TestPlainLogNone(t *testing.T) {
 	f, _ := New("plain")
 	out, err := f.Logs([]models.Log{})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, len(out), 0)
+	assert.Len(t, out, 0)
 }
 
 func TestPlainLogNoEntries(t *testing.T) {
 	f, _ := New("plain")
 	out, err := f.Log(models.Log{Name: "foo"})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, len(out), 0)
+	assert.Len(t, out, 0)
 }
 
 func TestPlainMetaEmpty(t *testing.T) {
 	f, _ := New("plain")
 	out, err := f.Meta(models.Meta{"foo", ""})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, len(out), 0)
+	assert.Len(t, out, 0)
 }
 
 func TestPlainMetaError(t *testing.T) {
 	f, _ := New("plain")
 	out, err := f.Meta(models.Meta{"foo", make(chan bool)})
-	be.Err(t, err)
+	assert.Error(t, err)
-	be.Equal(t, len(out), 0)
+	assert.Len(t, out, 0)
 }
 
 func TestPlainEntry(t *testing.T) {
@@ -134,6 +135,6 @@ func TestPlainEntry(t *testing.T) {
 		Title: "foo",
 		Date:  now,
 	})
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, string(out), fmt.Sprintf("Title: foo\nDate: %s", now.Format(tools.DateFormat)))
+	assert.Equal(t, fmt.Sprintf("Title: foo\nDate: %s", now.Format(tools.DateFormat)), string(out))
 }

go.mod

@@ -1,6 +1,6 @@
 module codeberg.org/danjones000/my-log
 
-go 1.26.0
+go 1.21.5
 
 require (
 	github.com/BurntSushi/toml v1.3.2
@@ -8,20 +8,25 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/markusmobius/go-dateparser v1.2.3
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/nalgeon/be v0.3.0
 	github.com/spf13/cobra v1.8.0
+	github.com/stretchr/testify v1.9.0
 )
 
 require (
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/elliotchance/pie/v2 v2.7.0 // indirect
 	github.com/hablullah/go-hijri v1.0.2 // indirect
 	github.com/hablullah/go-juliandays v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jalaali/go-jalaali v0.0.0-20210801064154-80525e88d958 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
 	github.com/magefile/mage v1.14.0 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/tetratelabs/wazero v1.2.1 // indirect
 	github.com/wasilibs/go-re2 v1.3.0 // indirect
 	golang.org/x/exp v0.0.0-20220321173239-a90fa8a75705 // indirect
 	golang.org/x/text v0.14.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -3,8 +3,9 @@ github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbi
 github.com/caarlos0/env/v10 v10.0.0 h1:yIHUBZGsyqCnpTkbjk8asUlx6RFhhEs+h7TOBdgdzXA=
 github.com/caarlos0/env/v10 v10.0.0/go.mod h1:ZfulV76NvVPw3tm591U4SwL3Xx9ldzBP9aGxzeN7G18=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/elliotchance/pie/v2 v2.7.0 h1:FqoIKg4uj0G/CrLGuMS9ejnFKa92lxE1dEgBD3pShXg=
 github.com/elliotchance/pie/v2 v2.7.0/go.mod h1:18t0dgGFH006g4eVdDtWfgFZPQEgl10IoEO8YWEq3Og=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -17,16 +18,21 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jalaali/go-jalaali v0.0.0-20210801064154-80525e88d958 h1:qxLoi6CAcXVzjfvu+KXIXJOAsQB62LXjsfbOaErsVzE=
 github.com/jalaali/go-jalaali v0.0.0-20210801064154-80525e88d958/go.mod h1:Wqfu7mjUHj9WDzSSPI5KfBclTTEnLveRUFr/ujWnTgE=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/magefile/mage v1.14.0 h1:6QDX3g6z1YvJ4olPhT1wksUcSa/V0a1B+pJb73fBjyo=
 github.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
 github.com/markusmobius/go-dateparser v1.2.3 h1:TvrsIvr5uk+3v6poDjaicnAFJ5IgtFHgLiuMY2Eb7Nw=
 github.com/markusmobius/go-dateparser v1.2.3/go.mod h1:cMwQRrBUQlK1UI5TIFHEcvpsMbkWrQLXuaPNMFzuYLk=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/nalgeon/be v0.3.0 h1:QsPANqEtcOD5qT2S3KAtIkDBBn8SXUf/Lb5Bi/z4UqM=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/nalgeon/be v0.3.0/go.mod h1:PMwMuBLopwKJkSHnr2qHyLcZYUTqNejN7A8RAqNWO3E=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
 github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
@@ -45,5 +51,7 @@ golang.org/x/exp v0.0.0-20220321173239-a90fa8a75705/go.mod h1:lgLbSvA5ygNOMpwM/9
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/testutil/bep/json.go

@@ -1,21 +0,0 @@
-package bep
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/nalgeon/be"
-)
-
-func JSON(t *testing.T, got, want []byte) {
-	t.Helper()
-
-	var gotAny, wantAny any
-	err := json.Unmarshal(want, &wantAny)
-	be.Err(t, err, nil)
-
-	err = json.Unmarshal(got, &gotAny)
-	be.Err(t, err, nil)
-
-	be.Equal(t, gotAny, wantAny)
-}

models/entry_test.go

@@ -4,13 +4,11 @@ import (
 	"bufio"
 	"encoding"
 	"encoding/json"
-	"regexp"
 	"strings"
 	"testing"
 	"time"
 
-	"codeberg.org/danjones000/my-log/internal/testutil/bep"
+	"github.com/stretchr/testify/assert"
-	"github.com/nalgeon/be"
 )
 
 // Type assertions
@@ -90,24 +88,6 @@ func TestEntryMarshal(t *testing.T) {
 			[]string{"@me:age 43", "@me:name:first Dan", "@me:name:last Jones"},
 			nil,
 		},
-		{
-			"double-nested-map-dot",
-			"Title DM",
-			when,
-			[]Meta{{"me", map[string]any{"age": 43, "name": map[string]any{".": "Dan Jones", "nick": "Danny"}}}},
-			"@begin " + whens + " - Title DM",
-			[]string{"@me:age 43", "@me:name Dan Jones", "@me:name:nick Danny"},
-			nil,
-		},
-		{
-			"double-nested-map-blank",
-			"Title DM",
-			when,
-			[]Meta{{"me", map[string]any{"age": 43, "name": map[string]any{"": "Dan Jones", "nick": "Danny"}}}},
-			"@begin " + whens + " - Title DM",
-			[]string{"@me:age 43", "@me:name Dan Jones", "@me:name:nick Danny"},
-			nil,
-		},
 		{
 			"nested-keys-in-json",
 			"Title NKJ",
@@ -128,19 +108,19 @@ func getEntryMarshalTestRunner(title string, date time.Time, fields []Meta, firs
 	return func(t *testing.T) {
 		en := Entry{title, date, fields}
 		o, er := en.MarshalText()
-		be.Err(t, er, err)
+		assert.Equal(t, err, er)
 		if first == "" {
 			return
 		}
 		os := string(o)
 		if len(lines) == 0 {
-			be.Equal(t, os, first)
+			assert.Equal(t, first, os)
 			return
 		}
 
-		be.True(t, regexp.MustCompile(first).MatchString(os))
+		assert.Regexp(t, first, os)
 		for _, line := range lines {
-			be.True(t, regexp.MustCompile("(?m)^"+line).MatchString(os))
+			assert.Regexp(t, "(?m)^"+line, os)
 		}
 	}
 }
@@ -189,14 +169,6 @@ func TestEntryUnmarshal(t *testing.T) {
 			[]Meta{{"me:name", "Dan"}, {"me:coder", true}},
 			nil,
 		},
-		{
-			"nested-field-dot",
-			"@begin " + whens + " - A Title\n@me:name Dan Jones\n@me:name:nick Danny\n@me:coder true @end",
-			"A Title",
-			when,
-			[]Meta{{"me:name", "Dan Jones"}, {"me:name:nick", "Danny"}, {"me:coder", true}},
-			nil,
-		},
 		{
 			"json-field",
 			"@begin " + whens + " - Some Guy\n" + `@json {"name":"Dan","coder":true} @end`,
@@ -217,12 +189,12 @@ func getEntryUnmarshalTestRunner(in string, title string, date time.Time, fields
 		e := &Entry{}
 		er := e.UnmarshalText([]byte(in))
 		if err != nil {
-			be.Err(t, er, err)
+			assert.ErrorIs(t, er, err)
 			return
 		}
 
-		be.Equal(t, e.Title, title)
+		assert.Equal(t, title, e.Title)
-		be.True(t, e.Date.After(date.Add(-time.Second)) && e.Date.Before(date.Add(time.Second)))
+		assert.WithinRange(t, e.Date, date.Add(-time.Second), date.Add(time.Second))
 		for _, f := range fields {
 			got := false
 			for _, m := range e.Fields {
@@ -239,7 +211,7 @@ func getEntryUnmarshalTestRunner(in string, title string, date time.Time, fields
 					break
 				}
 			}
-			be.True(t, got)
+			assert.Truef(t, got, "Couldn't find field %+v. We have %+v", f, e.Fields)
 		}
 	}
 }
@@ -249,13 +221,13 @@ func TestScan(t *testing.T) {
 	read := strings.NewReader(in)
 	scan := bufio.NewScanner(read)
 	scan.Split(scanEntry)
-	be.True(t, scan.Scan())
+	assert.True(t, scan.Scan())
-	be.Equal(t, scan.Text(), "@begin date - Title\nlong")
+	assert.Equal(t, "@begin date - Title\nlong", scan.Text())
-	be.True(t, scan.Scan())
+	assert.True(t, scan.Scan())
-	be.Equal(t, scan.Text(), "@foo john\njones")
+	assert.Equal(t, "@foo john\njones", scan.Text())
-	be.True(t, scan.Scan())
+	assert.True(t, scan.Scan())
-	be.Equal(t, scan.Text(), "@bar 42@nobody")
+	assert.Equal(t, "@bar 42@nobody", scan.Text())
-	be.True(t, !scan.Scan())
+	assert.False(t, scan.Scan())
 }
 
 func TestEntryJsonMarshal(t *testing.T) {
@@ -284,9 +256,6 @@ func TestEntryJsonMarshal(t *testing.T) {
 		{"nested-field", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:title", "Sub-title"}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","title":"Sub-title"}}`, nil},
 		{"double-nested-field", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:me:name", "Dan"}, {"obj:me:age", 27}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","me":{"name":"Dan","age":27}}}`, nil},
 		{"nested-plus-json", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:me", json.RawMessage(`{"name":"Dan","age":27}`)}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","me":{"name":"Dan","age":27}}}`, nil},
-		{"nested-part", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:me", "Dan"}, {"obj:me:age", 27}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","me":{".":"Dan","age":27}}}`, nil},
-		{"nested-part-order", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:me:age", 27}, {"obj:me", "Dan"}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","me":{".":"Dan","age":27}}}`, nil},
-		{"nested-part-order-two", "A Title", when, []Meta{{"obj:foo", "bar"}, {"obj:me:age", 27}, {"obj:me", "Dan"}, {"obj:me:cool", true}}, `{"title":"A Title","date":"` + whens + `","obj":{"foo":"bar","me":{".":"Dan","age":27,"cool":true}}}`, nil},
 	}
 
 	for _, tt := range tests {
@@ -299,9 +268,10 @@ func getEntryJsonMarshalTestRunner(title string, date time.Time, fields []Meta,
 		e := Entry{title, date, fields}
 		o, er := json.Marshal(e)
 		if err == nil {
-			bep.JSON(t, o, []byte(out))
+			assert.JSONEq(t, out, string(o))
+
 		} else {
-			be.Err(t, er, err)
+			assert.ErrorIs(t, er, err)
 		}
 	}
 }
@@ -377,14 +347,14 @@ func getEntryJsonUnmarshalTestRunner(in, title string, date time.Time, fields []
 		e := new(Entry)
 		er := e.UnmarshalJSON([]byte(in))
 		if err != nil {
-			be.Err(t, er, err)
+			assert.ErrorIs(t, er, err)
 			return
 		}
 
-		be.Equal(t, er, nil)
+		assert.Nil(t, er)
-		be.Equal(t, e.Title, title)
+		assert.Equal(t, title, e.Title)
-		be.True(t, e.Date.After(date.Add(-time.Second)) && e.Date.Before(date.Add(time.Second)))
+		assert.WithinRange(t, e.Date, date.Add(-time.Second), date.Add(time.Second))
-		be.Equal(t, len(e.Fields), len(fields))
+		assert.Len(t, e.Fields, len(fields))
 		for _, f := range fields {
 			got := false
 			fTime, isTime := f.Value.(time.Time)
@@ -403,13 +373,13 @@ func getEntryJsonUnmarshalTestRunner(in, title string, date time.Time, fields []
 				}
 				if isTime && m.Key == f.Key {
 					mTime, _ := mVal.(time.Time)
-					if mTime.After(fTime.Add(-2*time.Second)) && mTime.Before(fTime.Add(2*time.Second)) {
+					if assert.WithinRange(t, mTime, fTime.Add(-2*time.Second), fTime.Add(2*time.Second)) {
 						got = true
 						break
 					}
 				}
 			}
-			be.True(t, got)
+			assert.Truef(t, got, "Couldn't find field %+v. We have %+v", f, e.Fields)
 		}
 	}
 }

models/log_test.go

@@ -4,7 +4,8 @@ import (
 	"encoding"
 	"testing"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var _ encoding.TextUnmarshaler = new(Log)
@@ -31,15 +32,15 @@ const all = first + second + third + fourth + skip + fifth
 func TestLogUnmarshalBig(t *testing.T) {
 	l := &Log{Name: "test-log"}
 	err := l.UnmarshalText([]byte(all))
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, len(l.Entries), 5)
+	require.Len(t, l.Entries, 5)
 
 	var e Entry
 	var f bool
 	if e, f = findEntry(t, l, "This is simple", true); !f {
 		return
 	}
-	be.Equal(t, len(e.Fields), 0)
+	assert.Len(t, e.Fields, 0)
 
 	for _, e := range l.Entries {
 		findMeta(t, e, "ignoreme", true, false)
@@ -50,28 +51,28 @@ func TestLogUnmarshalIgnoreGarbage(t *testing.T) {
 	l := &Log{Name: "test-log"}
 	in := "ignore this\n" + second + "some crap also skip -> " + third + skip
 	err := l.UnmarshalText([]byte(in))
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, len(l.Entries), 1)
+	require.Len(t, l.Entries, 1)
 
 	en := l.Entries[0]
-	be.Equal(t, en.Title, "We have one thing here")
+	assert.Equal(t, "We have one thing here", en.Title)
-	be.Equal(t, len(en.Fields), 1)
+	assert.Len(t, en.Fields, 1)
-	be.Equal(t, en.Fields[0].Key, "foo")
+	assert.Equal(t, "foo", en.Fields[0].Key)
-	be.Equal(t, en.Fields[0].Value, "bar")
+	assert.Equal(t, "bar", en.Fields[0].Value)
 }
 
 func TestLogUnmarshalEmpty(t *testing.T) {
 	l := &Log{Name: "test-log"}
 	err := l.UnmarshalText([]byte{})
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, len(l.Entries), 0)
+	require.Len(t, l.Entries, 0)
 }
 
 func TestLogUnmarshalBad(t *testing.T) {
 	l := &Log{Name: "test-log"}
 	err := l.UnmarshalText([]byte(badEntry))
-	be.Err(t, err, nil)
+	require.NoError(t, err)
-	be.Equal(t, len(l.Entries), 0)
+	require.Len(t, l.Entries, 0)
 }
 
 func findEntry(t *testing.T, log *Log, title string, shouldFind bool) (Entry, bool) {
@@ -84,9 +85,9 @@ func findEntry(t *testing.T, log *Log, title string, shouldFind bool) (Entry, bo
 		}
 	}
 	if shouldFind {
-		be.True(t, found)
+		found = assert.Truef(t, found, "Unable to found entry %s", title)
 	} else {
-		be.True(t, !found)
+		found = assert.Falsef(t, found, "Entry %s should not have been found but was", title)
 	}
 
 	return ret, found
@@ -102,9 +103,9 @@ func findMeta(t *testing.T, entry Entry, key string, value any, shouldFind bool)
 		}
 	}
 	if shouldFind {
-		be.True(t, found)
+		found = assert.Truef(t, found, "Unable to found meta %s", key)
 	} else {
-		be.True(t, !found)
+		found = assert.Falsef(t, found, "Meta %s should not have been found but was", key)
 	}
 
 	return ret, found

models/meta.go

@@ -50,16 +50,12 @@ func marshalMap(pre string, mp map[string]any, buff *bytes.Buffer) error {
 			buff.WriteRune('\n')
 		}
 		idx++
-		newKey := pre + ":" + k
-		if k == "." || k == "" {
-			newKey = pre
-		}
 		if subM, ok := v.(map[string]any); ok {
-			if err := marshalMap(newKey, subM, buff); err != nil {
+			if err := marshalMap(pre+":"+k, subM, buff); err != nil {
 				return err
 			}
 		} else {
-			mSub := Meta{newKey, v}
+			mSub := Meta{pre + ":" + k, v}
 			if err := mSub.marshalToBuff(buff); err != nil {
 				return err
 			}

models/meta_test.go

@@ -7,8 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"codeberg.org/danjones000/my-log/internal/testutil/bep"
+	"github.com/stretchr/testify/assert"
-	"github.com/nalgeon/be"
 )
 
 // Type assertions
@@ -73,8 +72,8 @@ func getMetaTestRunner(key string, value any, out string, err error, newVal any)
 		if valE, ok := value.(error); !ok || !errors.Is(valE, skipMarshalTest) {
 			var o []byte
 			o, e = st.MarshalText()
-			be.Equal(t, string(o), out)
+			assert.Equal(t, out, string(o))
-			be.Equal(t, e, err)
+			assert.Equal(t, err, e)
 			if e != nil {
 				return
 			}
@@ -84,16 +83,17 @@ func getMetaTestRunner(key string, value any, out string, err error, newVal any)
 			e = n.UnmarshalText([]byte(out))
 		}
 		if newE, ok := newVal.(error); ok {
-			be.Err(t, e, newE)
+			assert.ErrorIs(t, e, newE)
 		} else {
-			be.Equal(t, n.Key, key)
+			assert.Equal(t, key, n.Key)
 			if ti, ok := newVal.(time.Time); ok {
 				valT, ok := n.Value.(time.Time)
-				be.True(t, ok)
+				if assert.True(t, ok) {
-				be.True(t, valT.After(ti.Add(-time.Second)) && valT.Before(ti.Add(time.Second)))
+					assert.WithinRange(t, valT, ti.Add(-time.Second), ti.Add(time.Second))
+				}
 
 			} else {
-				be.Equal(t, n.Value, newVal)
+				assert.Equal(t, newVal, n.Value)
 			}
 		}
 	}
@@ -103,42 +103,42 @@ func TestMetasJson(t *testing.T) {
 	ms := Metas{{"me", 41}, {"you", false}}
 	exp := `{"me":41,"you":false}`
 	o, err := json.Marshal(ms)
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	bep.JSON(t, o, []byte(exp))
+	assert.JSONEq(t, exp, string(o))
 }
 
 func TestMetasJsonUnmarshal(t *testing.T) {
 	ms := Metas{}
 	in := `{"me":"cool","you":false}`
 	err := json.Unmarshal([]byte(in), &ms)
-	be.Err(t, err, nil)
+	assert.NoError(t, err)
-	be.Equal(t, len(ms), 2)
+	assert.Len(t, ms, 2)
-	be.Equal(t, ms, Metas{
+	assert.ElementsMatch(t, Metas{
 		{"me", "cool"},
 		{"you", false},
-	})
+	}, ms)
 }
 
 func TestMetasJsonError(t *testing.T) {
 	ms := Metas{}
 	in := "not json"
 	err := (&ms).UnmarshalJSON([]byte(in))
-	be.Err(t, err)
+	assert.Error(t, err)
-	be.Equal(t, len(ms), 0)
+	assert.Len(t, ms, 0)
 }
 
 func TestMetasAppend(t *testing.T) {
 	ms := Metas{}
 	ms = ms.Append("foo", 42)
-	be.Equal(t, len(ms), 1)
+	assert.Len(t, ms, 1)
-	be.Equal(t, ms[0], Meta{"foo", 42})
+	assert.Equal(t, Meta{"foo", 42}, ms[0])
 }
 
 func TestMetasAppendTo(t *testing.T) {
 	ms := &Metas{}
 	ms.AppendTo("foo", 42)
-	be.Equal(t, len(*ms), 1)
+	assert.Len(t, *ms, 1)
-	be.Equal(t, (*ms)[0], Meta{"foo", 42})
+	assert.Equal(t, Meta{"foo", 42}, (*ms)[0])
 }
 
 func TestMetasSet(t *testing.T) {
@@ -196,7 +196,7 @@ func TestMetasSet(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result := tt.initial.Set(tt.key, tt.value)
-			be.Equal(t, result, tt.expected)
+			assert.ElementsMatch(t, tt.expected, result)
 		})
 	}
 }
@@ -205,14 +205,14 @@ func TestMetasGet(t *testing.T) {
 	ms := Metas{{"foo", 42}, {"bar", "hello"}}
 
 	val, found := ms.Get("foo")
-	be.True(t, found)
+	assert.True(t, found)
-	be.Equal(t, val, 42)
+	assert.Equal(t, 42, val)
 
 	val, found = ms.Get("bar")
-	be.True(t, found)
+	assert.True(t, found)
-	be.Equal(t, val, "hello")
+	assert.Equal(t, "hello", val)
 
 	val, found = ms.Get("baz")
-	be.True(t, !found)
+	assert.False(t, found)
-	be.Equal(t, val, nil)
+	assert.Nil(t, val)
 }

models/metas.go

@@ -42,7 +42,6 @@ func (ms Metas) Map() map[string]any {
 }
 
 func parseNestedFields(f map[string]any) {
-	todelete := make([]string, 0, len(f))
 	for k, v := range f {
 		if strings.Contains(k, ":") {
 			idx := strings.Index(k, ":")
@@ -51,28 +50,14 @@ func parseNestedFields(f map[string]any) {
 
 			nest, ok := f[top].(map[string]any)
 			if !ok {
-				curr := f[top]
+				nest = map[string]any{}
-				if curr == nil {
-					nest = map[string]any{}
-				} else {
-					nest = map[string]any{".": curr}
-				}
-			}
-
-			curr, ok := nest[bottom].(map[string]any)
-			if ok {
-				curr["."] = v
-			} else {
-				nest[bottom] = v
 			}
+			nest[bottom] = v
 			parseNestedFields(nest)
 			f[top] = nest
-			todelete = append(todelete, k)
+			delete(f, k)
 		}
 	}
-	for _, k := range todelete {
-		delete(f, k)
-	}
 }
 
 // Implements json.Marshaler

tools/parse_date_test.go

@@ -5,7 +5,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const day = time.Hour * 24
@@ -57,10 +58,11 @@ func getDateTest(in string, exp time.Time, err string) func(t *testing.T) {
 	return func(t *testing.T) {
 		out, er := ParseDate(in)
 		if err != "" {
-			be.Err(t, er, err)
+			assert.ErrorContains(t, er, err)
 		} else {
-			be.Err(t, er, nil)
+			require.NoError(t, er)
-			be.Equal(t, out, exp)
+
+			assert.Equal(t, exp, out)
 		}
 	}
 }

tools/parse_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestParse(t *testing.T) {
@@ -54,18 +54,20 @@ func getParseTestRunner(in string, exp any) func(*testing.T) {
 		out := ParseString(in)
 		if expT, ok := exp.(time.Time); ok {
 			ti, gotTime := out.(time.Time)
-			be.True(t, gotTime)
+			if assert.True(t, gotTime, "Should have gotten a time.Time, but didn't") {
-			be.True(t, expT.After(ti.Add(-2*time.Second)) && expT.Before(ti.Add(2*time.Second)))
+				assert.WithinRange(t, expT, ti.Add(-2*time.Second), ti.Add(2*time.Second))
+			}
 		} else {
-			be.Equal(t, out, exp)
+			assert.Equal(t, exp, out)
 		}
 		out = ParseBytes([]byte(in))
 		if expT, ok := exp.(time.Time); ok {
 			ti, gotTime := out.(time.Time)
-			be.True(t, gotTime)
+			if assert.True(t, gotTime, "Should have gotten a time.Time, but didn't") {
-			be.True(t, expT.After(ti.Add(-2*time.Second)) && expT.Before(ti.Add(2*time.Second)))
+				assert.WithinRange(t, expT, ti.Add(-2*time.Second), ti.Add(2*time.Second))
+			}
 		} else {
-			be.Equal(t, out, exp)
+			assert.Equal(t, exp, out)
 		}
 	}
 }

tools/write_buffer_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/nalgeon/be"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestWriteBuffer(t *testing.T) {
@@ -52,8 +52,8 @@ func getWriteTestRunner(value any, out string, err error) func(*testing.T) {
 	return func(t *testing.T) {
 		buff := &bytes.Buffer{}
 		n, er := WriteValue(buff, value)
-		be.Equal(t, n, len(out))
+		assert.Equal(t, len(out), n)
-		be.Equal(t, er, err)
+		assert.Equal(t, err, er)
-		be.Equal(t, buff.String(), out)
+		assert.Equal(t, out, buff.String())
 	}
 }