dan/my-log
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

✨ Migrate from testify to nalgeon/be testing library

Browse source 
- Replace all testify/assert and testify/require with be library
- Update go.mod to use be v0.3.0 instead of testify
- Simplify test assertions using be.Equal, be.Err, and be.True
- Refactor append_test, entry_test, meta_test, log_test, and formatter tests
This commit is contained in:
Dan Jones 2026-02-13 14:12:30 -06:00
commit 1110288d84
16 changed files with 226 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

38
formatters/json_test.go
View file

@ -1,17 +1,18 @@
package formatters
import (
"encoding/json"
"fmt"
"testing"
"time"
"codeberg.org/danjones000/my-log/models"
"github.com/stretchr/testify/assert"
"github.com/nalgeon/be"
)
func TestJsonName(t *testing.T) {
f, _ := New("json")
assert.Equal(t, "json", f.Name())
be.Equal(t, f.Name(), "json")
}
func TestJsonMeta(t *testing.T) {
@ -19,8 +20,11 @@ func TestJsonMeta(t *testing.T) {
m := models.Meta{"foo", 42}
exp := `{"foo":42}`
o, err := f.Meta(m)
assert.NoError(t, err)
assert.JSONEq(t, exp, string(o))
be.Err(t, err, nil)
var got, want any
json.Unmarshal([]byte(exp), &want)
json.Unmarshal(o, &got)
be.Equal(t, got, want)
}
func TestJsonEntry(t *testing.T) {
@ -34,8 +38,11 @@ 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)
assert.NoError(t, err)
assert.JSONEq(t, exp, string(o))
be.Err(t, err, nil)
var got, want any
json.Unmarshal([]byte(exp), &want)
json.Unmarshal(o, &got)
be.Equal(t, got, want)
}
func TestJsonLog(t *testing.T) {
@ -50,24 +57,27 @@ 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)
assert.NoError(t, err)
assert.JSONEq(t, exp, string(o))
be.Err(t, err, nil)
var got, want any
json.Unmarshal([]byte(exp), &want)
json.Unmarshal(o, &got)
be.Equal(t, got, want)
}
func TestJsonNoLogs(t *testing.T) {
f, _ := New("json")
o, err := f.Logs([]models.Log{})
var exp []byte
assert.NoError(t, err)
assert.Equal(t, exp, o)
be.Err(t, err, nil)
be.Equal(t, o, exp)
}
func TestJsonErr(t *testing.T) {
f, _ := New("json")
o, err := f.Meta(models.Meta{"foo", make(chan bool)})
var exp []byte
assert.Error(t, err)
assert.Equal(t, exp, o)
be.Err(t, err)
be.Equal(t, o, exp)
}
func TestJsonPretty(t *testing.T) {
@ -76,6 +86,6 @@ func TestJsonPretty(t *testing.T) {
exp := `{
"foo": 42
}`
assert.NoError(t, err)
assert.Equal(t, exp, string(o))
be.Err(t, err, nil)
be.Equal(t, string(o), exp)
}

24
formatters/new_test.go
View file

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

22
formatters/null_test.go
View file

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

55
formatters/plain_test.go
View file

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