509 lines
9.4 KiB
Go
509 lines
9.4 KiB
Go
package task_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"go-mod.ewintr.nl/go-kit/test"
|
|
"go-mod.ewintr.nl/gte/internal/task"
|
|
"go-mod.ewintr.nl/gte/pkg/mstore"
|
|
)
|
|
|
|
func TestNewFromMessage(t *testing.T) {
|
|
id := "an id"
|
|
version := 2
|
|
action := "some action"
|
|
project := "project"
|
|
date := task.NewDate(2021, 1, 20)
|
|
recurs := "2021-06-04, daily"
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
message *mstore.Message
|
|
hasId bool
|
|
exp *task.Task
|
|
}{
|
|
{
|
|
name: "empty",
|
|
message: &mstore.Message{},
|
|
exp: &task.Task{},
|
|
},
|
|
{
|
|
name: "id, action, project, folder and done",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_UNPLANNED,
|
|
Body: fmt.Sprintf(`
|
|
id: %s
|
|
due: no date
|
|
version: %d
|
|
action: %s
|
|
project: %s
|
|
done: true
|
|
`, id, version, action, project),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Version: version,
|
|
Folder: task.FOLDER_UNPLANNED,
|
|
Action: action,
|
|
Project: project,
|
|
Done: true,
|
|
},
|
|
},
|
|
{
|
|
name: "with date",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Body: fmt.Sprintf(`
|
|
id: %s
|
|
due: %s
|
|
version: %d
|
|
action: %s
|
|
`, id, date.String(), version, action),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Folder: task.FOLDER_PLANNED,
|
|
Action: action,
|
|
Version: version,
|
|
Due: date,
|
|
},
|
|
},
|
|
{
|
|
name: "action in body takes precedence",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Subject: "some other action",
|
|
Body: fmt.Sprintf(`
|
|
id: %s
|
|
due: no date
|
|
version: %d
|
|
action: %s
|
|
`, id, version, action),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Version: version,
|
|
Folder: task.FOLDER_PLANNED,
|
|
Action: action,
|
|
},
|
|
},
|
|
{
|
|
name: "action from subject if not present in body",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Subject: action,
|
|
Body: fmt.Sprintf(`id: %s`, id),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Folder: task.FOLDER_PLANNED,
|
|
Action: action,
|
|
},
|
|
},
|
|
{
|
|
name: "project in body takes precedence",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Subject: fmt.Sprintf("old project - %s", action),
|
|
Body: fmt.Sprintf(`
|
|
id: %s
|
|
due: no date
|
|
version: %d
|
|
action: %s
|
|
project: %s
|
|
`, id, version, action, project),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Version: version,
|
|
Folder: task.FOLDER_PLANNED,
|
|
Action: action,
|
|
Project: project,
|
|
},
|
|
},
|
|
{
|
|
name: "quoted fields",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Body: fmt.Sprintf(`
|
|
action: %s
|
|
|
|
Forwarded message:
|
|
> id: %s
|
|
> action: old action
|
|
`, action, id),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Folder: task.FOLDER_PLANNED,
|
|
Action: action,
|
|
},
|
|
},
|
|
{
|
|
name: "recur",
|
|
message: &mstore.Message{
|
|
Folder: task.FOLDER_INBOX,
|
|
Body: fmt.Sprintf(`
|
|
action: %s
|
|
due: no date
|
|
recur: %s
|
|
project: %s
|
|
id :%s
|
|
version: %d
|
|
`, action, recurs, project, id, version),
|
|
},
|
|
hasId: true,
|
|
exp: &task.Task{
|
|
Id: id,
|
|
Version: version,
|
|
Folder: task.FOLDER_INBOX,
|
|
Action: action,
|
|
Project: project,
|
|
Recur: task.Daily{Start: task.NewDate(2021, 6, 4)},
|
|
},
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
act := task.NewFromMessage(tc.message)
|
|
if !tc.hasId {
|
|
test.Equals(t, false, "" == act.Id)
|
|
tc.exp.Id = act.Id
|
|
}
|
|
tc.exp.Message = tc.message
|
|
test.Equals(t, tc.exp, act)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTaskTargetFolder(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
tsk *task.Task
|
|
expFolder string
|
|
}{
|
|
{
|
|
name: "new",
|
|
tsk: &task.Task{},
|
|
expFolder: task.FOLDER_NEW,
|
|
},
|
|
{
|
|
name: "recurring",
|
|
tsk: &task.Task{
|
|
Id: "id",
|
|
Version: 2,
|
|
Project: "project",
|
|
Recur: task.Daily{Start: task.NewDate(2021, 06, 21)},
|
|
},
|
|
expFolder: task.FOLDER_RECURRING,
|
|
},
|
|
{
|
|
name: "planned",
|
|
tsk: &task.Task{
|
|
Id: "id",
|
|
Version: 2,
|
|
Project: "project",
|
|
Due: task.NewDate(2021, 06, 21),
|
|
},
|
|
expFolder: task.FOLDER_PLANNED,
|
|
},
|
|
{
|
|
name: "unplanned",
|
|
tsk: &task.Task{
|
|
Id: "id",
|
|
Version: 2,
|
|
Project: "project",
|
|
},
|
|
expFolder: task.FOLDER_UNPLANNED,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
test.Equals(t, tc.tsk.TargetFolder(), tc.expFolder)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTaskNextMessage(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
tsk *task.Task
|
|
expMessage *mstore.Message
|
|
}{
|
|
{
|
|
name: "empty",
|
|
tsk: &task.Task{},
|
|
expMessage: &mstore.Message{
|
|
Folder: task.FOLDER_NEW,
|
|
Subject: "",
|
|
Body: "\r\naction:\r\ndue: no date\r\nproject:\r\nversion: 1\r\nid:\r\n",
|
|
},
|
|
},
|
|
{
|
|
name: "normal",
|
|
tsk: &task.Task{
|
|
Id: "id",
|
|
Version: 3,
|
|
Folder: task.FOLDER_INBOX,
|
|
Action: "action",
|
|
Project: "project",
|
|
Due: task.NewDate(2021, 06, 22),
|
|
},
|
|
expMessage: &mstore.Message{
|
|
Folder: task.FOLDER_PLANNED,
|
|
Subject: "2021-06-22 (tuesday) - project - action",
|
|
Body: "\r\naction: action\r\ndue: 2021-06-22 (tuesday)\r\nproject: project\r\nversion: 4\r\nid: id\r\n",
|
|
},
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
test.Equals(t, tc.expMessage, tc.tsk.NextMessage())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFormatSubject(t *testing.T) {
|
|
action := "an action"
|
|
project := " a project"
|
|
due := task.NewDate(2021, 1, 30)
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
task *task.Task
|
|
exp string
|
|
}{
|
|
{
|
|
name: "empty",
|
|
task: &task.Task{},
|
|
},
|
|
{
|
|
name: "action",
|
|
task: &task.Task{
|
|
Action: action,
|
|
},
|
|
exp: action,
|
|
},
|
|
{
|
|
name: "project",
|
|
task: &task.Task{
|
|
Project: project,
|
|
},
|
|
exp: project,
|
|
},
|
|
{
|
|
name: "action and project",
|
|
task: &task.Task{
|
|
Action: action,
|
|
Project: project,
|
|
},
|
|
exp: fmt.Sprintf("%s - %s", project, action),
|
|
},
|
|
{
|
|
name: "action, date and project",
|
|
task: &task.Task{
|
|
Action: action,
|
|
Project: project,
|
|
Due: due,
|
|
},
|
|
exp: fmt.Sprintf("%s - %s - %s", due.String(), project, action),
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
test.Equals(t, tc.exp, tc.task.FormatSubject())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFormatBody(t *testing.T) {
|
|
id := "an id"
|
|
version := 6
|
|
action := "an action"
|
|
project := "project"
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
task *task.Task
|
|
exp string
|
|
}{
|
|
{
|
|
name: "empty",
|
|
task: &task.Task{},
|
|
exp: "\r\naction:\r\ndue: no date\r\nproject:\r\nversion: 0\r\nid:\r\n",
|
|
},
|
|
{
|
|
name: "filled",
|
|
task: &task.Task{
|
|
Id: id,
|
|
Version: version,
|
|
Action: action,
|
|
Project: project,
|
|
Done: true,
|
|
Due: task.NewDate(2021, 1, 30),
|
|
Message: &mstore.Message{
|
|
Body: "previous body",
|
|
},
|
|
},
|
|
exp: "\r\naction: an action\r\ndue: 2021-01-30 (saturday)\r\nproject: project\r\nversion: 6\r\nid: an id\r\ndone: true\r\n",
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
test.Equals(t, tc.exp, tc.task.FormatBody())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldFromBody(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
field string
|
|
body string
|
|
expValue string
|
|
}{
|
|
{
|
|
name: "empty field",
|
|
body: `field: value`,
|
|
},
|
|
{
|
|
name: "empty body",
|
|
field: "field",
|
|
},
|
|
{
|
|
name: "not present",
|
|
field: "field",
|
|
body: "another: value",
|
|
},
|
|
{
|
|
name: "present",
|
|
field: "fieldb",
|
|
body: `
|
|
not a field at all
|
|
|
|
fielda: valuea
|
|
fieldb: valueb
|
|
fieldc: valuec
|
|
`,
|
|
expValue: "valueb",
|
|
},
|
|
{
|
|
name: "present twice",
|
|
field: "field",
|
|
body: `
|
|
field: valuea
|
|
field: valueb
|
|
`,
|
|
expValue: "valuea",
|
|
},
|
|
{
|
|
name: "colons",
|
|
field: "field",
|
|
body: "field:: val:ue",
|
|
expValue: ": val:ue",
|
|
},
|
|
{
|
|
name: "trim field",
|
|
field: "field",
|
|
body: " field : value",
|
|
expValue: "value",
|
|
},
|
|
{
|
|
name: "trim value",
|
|
field: "field",
|
|
body: "field: value ",
|
|
expValue: "value",
|
|
},
|
|
{
|
|
name: "quoted",
|
|
|
|
field: "field",
|
|
body: "> field: value",
|
|
expValue: "value",
|
|
},
|
|
{
|
|
name: "previous body",
|
|
field: "field",
|
|
body: `
|
|
field: valuea
|
|
|
|
Previous version:
|
|
|
|
field: valueb
|
|
`,
|
|
expValue: "valuea",
|
|
},
|
|
{
|
|
name: "quoted previous body",
|
|
field: "field",
|
|
body: `
|
|
field: valuea
|
|
|
|
> Previous version:
|
|
>
|
|
> field: valueb
|
|
`,
|
|
expValue: "valuea",
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
actValue := task.FieldFromBody(tc.field, tc.body)
|
|
test.Equals(t, tc.expValue, actValue)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldFromSubject(t *testing.T) {
|
|
action := "action"
|
|
project := "project"
|
|
due := "due"
|
|
subjectOne := fmt.Sprintf("%s", action)
|
|
subjectTwo := fmt.Sprintf("%s - %s", project, action)
|
|
subjectThree := fmt.Sprintf("%s - %s - %s", due, project, action)
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
field string
|
|
subject string
|
|
exp string
|
|
}{
|
|
{
|
|
name: "empty field",
|
|
subject: action,
|
|
},
|
|
{
|
|
name: "empty subject",
|
|
field: task.FIELD_ACTION,
|
|
},
|
|
{
|
|
name: "unknown field",
|
|
field: "unknown",
|
|
subject: subjectOne,
|
|
},
|
|
{
|
|
name: "action with one",
|
|
field: task.FIELD_ACTION,
|
|
subject: subjectOne,
|
|
exp: action,
|
|
},
|
|
{
|
|
name: "action with with two",
|
|
field: task.FIELD_ACTION,
|
|
subject: subjectTwo,
|
|
exp: action,
|
|
},
|
|
{
|
|
name: "action with three",
|
|
field: task.FIELD_ACTION,
|
|
subject: subjectThree,
|
|
exp: action,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
test.Equals(t, tc.exp, task.FieldFromSubject(tc.field, tc.subject))
|
|
})
|
|
}
|
|
}
|