local
/
todo-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

almost there but tasks dont disappear in UI and click&drag doesnt work

master
Bel LaPointe 2019-11-14 14:25:16 -07:00
parent cf1fd1dfed
commit b6397a71d4
11 changed files with 325 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
server/ajax/ajax_test.go
View File

@ -15,6 +15,5 @@ func mockAjax() *Ajax {
if err != nil {
panic(err)
}
ajax.storageSetCur("list")
return ajax
}

15
server/ajax/form/uuid.go Normal file
View File

@ -0,0 +1,15 @@
package form
import (
"fmt"
"hash/fnv"
"github.com/google/uuid"
)
func NewUUID() string {
uuid := uuid.New().String()
h := fnv.New32a()
h.Write([]byte(uuid))
return fmt.Sprint(h.Sum32())
}

20
server/ajax/form/uuid_test.go Normal file
View File

@ -0,0 +1,20 @@
package form
import (
"strconv"
"testing"
)
func TestUUID(t *testing.T) {
seen := map[string]struct{}{}
for i := 0; i < 50; i++ {
v := NewUUID()
if _, ok := seen[v]; ok {
t.Error(ok)
}
if _, err := strconv.Atoi(v); err != nil {
t.Error(err)
}
seen[v] = struct{}{}
}
}

45
server/ajax/list.go
View File

@ -3,6 +3,7 @@ package ajax
import (
"encoding/json"
"errors"
"local/todo-server/server/ajax/form"
"local/todo-server/server/ajax/list"
"net/http"
)
@ -14,15 +15,6 @@ func (a *Ajax) loadLists(w http.ResponseWriter, r *http.Request) error {
if err != nil {
return err
}
// TODO
lists = append(lists, &list.List{
ID: "Todo",
UUID: "Todo",
})
if err := a.storageSetList(lists[0].ID, lists[0]); err != nil {
return err
}
// /TODO
return json.NewEncoder(w).Encode(map[string]interface{}{
"total": len(lists),
"list": lists,
@ -34,16 +26,43 @@ func (a *Ajax) changeOrder(w http.ResponseWriter, r *http.Request) error {
}
func (a *Ajax) addList(w http.ResponseWriter, r *http.Request) error {
// {"total":1,"list":[{"id":"21","name":"abc","sort":0,"published":0,"showCompl":0,"showNotes":0,"hidden":0}]}
return errors.New("not impl")
newList, err := list.New(r)
if err != nil {
return err
}
if err := a.storageSetList(newList); err != nil {
return err
}
return json.NewEncoder(w).Encode(map[string]interface{}{
"total": 1,
"list": []*list.List{newList},
})
}
func (a *Ajax) renameList(w http.ResponseWriter, r *http.Request) error {
return errors.New("not impl")
uuid := form.Get(r, "list")
renameList, err := a.storageGetList(uuid)
if err != nil {
return err
}
renameList.SetName(form.Get(r, "name"))
if err := a.storageSetList(renameList); err != nil {
return err
}
return json.NewEncoder(w).Encode(map[string]interface{}{
"total": 1,
"list": []*list.List{renameList},
})
}
func (a *Ajax) deleteList(w http.ResponseWriter, r *http.Request) error {
return errors.New("not impl")
uuid := form.Get(r, "list")
if err := a.storageDelList(uuid); err != nil {
return err
}
return json.NewEncoder(w).Encode(map[string]interface{}{
"total": 1,
})
}
func (a *Ajax) setSort(w http.ResponseWriter, r *http.Request) error {

59
server/ajax/list/list.go
View File

@ -2,11 +2,12 @@ package list
import (
"errors"
"local/todo-server/server/ajax/form"
"net/http"
)
type List struct {
ID string `json:"name"`
Name string `json:"name"`
UUID string `json:"id"`
Sort int `json:"sort"`
Published int `json:"published"`
@ -16,49 +17,39 @@ type List struct {
}
func New(r *http.Request) (*List, error) {
return &List{}, errors.New("not impl")
name := form.Get(r, "name")
if name == "" {
return nil, errors.New("no name given")
}
return &List{
Name: name,
UUID: form.NewUUID(),
}, nil
}
func (l *List) loadLists() error {
return errors.New("not impl")
func (l *List) SetName(name string) {
l.Name = name
}
func (l *List) changeOrder() error {
return errors.New("not impl")
func (l *List) SetPublished(state bool) {
set(state, &l.Published)
}
func (l *List) addList() error {
return errors.New("not impl")
func (l *List) SetShowCompl(state bool) {
set(state, &l.ShowCompl)
}
func (l *List) renameList() error {
return errors.New("not impl")
func (l *List) SetShowNotes(state bool) {
set(state, &l.ShowNotes)
}
func (l *List) deleteList() error {
return errors.New("not impl")
func (l *List) SetHideList(state bool) {
set(state, &l.Hidden)
}
func (l *List) setSort() error {
return errors.New("not impl")
}
func (l *List) publishList() error {
return errors.New("not impl")
}
func (l *List) changeListOrder() error {
return errors.New("not impl")
}
func (l *List) clearCompletedInList() error {
return errors.New("not impl")
}
func (l *List) setShowNotesInList() error {
return errors.New("not impl")
}
func (l *List) setHideList() error {
return errors.New("not impl")
func set(b bool, i *int) {
*i = 1
if !b {
*i = 0
}
}

110
server/ajax/list_test.go Normal file
View File

@ -0,0 +1,110 @@
package ajax
import (
"encoding/json"
"errors"
"fmt"
"local/todo-server/server/ajax/form"
"local/todo-server/server/ajax/list"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestAjaxLoadLists(t *testing.T) {
ajax := mockAjax()
for i := 0; i < 3; i++ {
l := &list.List{
Name: fmt.Sprintf("list_%v", i),
UUID: form.NewUUID(),
}
if err := ajax.storageSetList(l); err != nil {
t.Fatal(err)
}
}
w := httptest.NewRecorder()
r := httptest.NewRequest("GET", "/", nil)
ajax.loadLists(w, r)
lists := getListsFromResp(w)
if len(lists) < 3 {
t.Fatal(lists)
}
}
func TestAjaxAddList(t *testing.T) {
ajax := mockAjax()
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/", strings.NewReader(`name=abc`))
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
ajax.addList(w, r)
lists := getListsFromResp(w)
if len(lists) < 1 {
t.Fatal(lists)
}
if err := testAjaxHasListWithName(ajax, lists[0].UUID, "abc"); err != nil {
t.Error(err)
}
}
func TestAjaxRenameList(t *testing.T) {
ajax := mockAjax()
l := &list.List{
UUID: "a",
Name: "b",
}
ajax.storageSetList(l)
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/", strings.NewReader(`list=a&name=c`))
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
ajax.renameList(w, r)
lists := getListsFromResp(w)
if err := testAjaxHasListWithName(ajax, lists[0].UUID, "c"); err != nil {
t.Error(err)
}
}
func TestAjaxDeleteList(t *testing.T) {
ajax := mockAjax()
l := &list.List{
UUID: "a",
Name: "b",
}
ajax.storageSetList(l)
if _, err := ajax.storageGetList(l.UUID); err != nil {
t.Error(err)
}
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/", strings.NewReader(`list=a`))
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
ajax.deleteList(w, r)
lists := getListsFromResp(w)
if len(lists) > 0 {
t.Error(lists)
}
if _, err := ajax.storageGetList(l.UUID); err == nil {
t.Error(err)
}
}
func testAjaxHasListWithName(ajax *Ajax, uuid, name string) error {
list, err := ajax.storageGetList(uuid)
if err != nil {
return err
}
if list.Name != name {
return errors.New(list.Name)
}
return nil
}
func getListsFromResp(b *httptest.ResponseRecorder) []*list.List {
if b.Code != http.StatusOK {
return nil
}
var resp struct {
List []*list.List `json:"list"`
}
json.Unmarshal(b.Body.Bytes(), &resp)
return resp.List
}

82
server/ajax/storage.go
View File

@ -14,23 +14,26 @@ import (
func (a *Ajax) Cur(r *http.Request) (string, string, []string) {
listID := form.Get(r, "list")
taskID := form.Get(r, "id")
if listID == "" {
a.storageGet(path.Join("task", taskID, "map"), &listID)
}
tags, _ := r.URL.Query()["t"]
return listID, taskID, tags
}
func (a *Ajax) storageListLists(filters ...func(t *list.List) bool) ([]*list.List, error) {
results, err := a.DB.List(nil, "", "}")
results, err := a.DB.List(nil, path.Join("list"), path.Join("list", "}"))
if err != nil {
return nil, err
}
lists := []*list.List{}
for _, result := range results {
if d, f := path.Split(result); d == "" || f == "" {
if d := path.Dir(result); d != "list" {
continue
}
list := &list.List{
ID: result,
UUID: result,
list, err := a.storageGetList(path.Base(result))
if err != nil {
return nil, err
}
filtered := true
for _, f := range filters {
@ -47,14 +50,17 @@ func (a *Ajax) storageListLists(filters ...func(t *list.List) bool) ([]*list.Lis
}
func (a *Ajax) storageListTasks(listID string, filters ...func(t *task.Task) bool) ([]*task.Task, error) {
results, err := a.DB.List(nil, listID+"/", listID+"/}")
results, err := a.DB.List(nil, path.Join("list", listID, "task"), path.Join("list", listID, "task", "}"))
if err != nil {
return nil, err
}
tasks := []*task.Task{}
for _, result := range results {
taskID := strings.TrimPrefix(result, listID+"/")
task, err := a.storageGetTask(listID, taskID)
taskID := path.Base(result)
if taskID == "" {
continue
}
task, err := a.storageGetTask(taskID)
if err != nil {
return nil, err
}
@ -72,55 +78,53 @@ func (a *Ajax) storageListTasks(listID string, filters ...func(t *task.Task) boo
return tasks, nil
}
func (a *Ajax) storageGetTask(listID, taskID string) (*task.Task, error) {
func (a *Ajax) storageGetTask(taskID string) (*task.Task, error) {
var listID string
if err := a.storageGet(path.Join("task", taskID, "map"), &listID); err != nil {
return nil, err
}
var task task.Task
err := a.storageGet(path.Join(listID, taskID), &task)
err := a.storageGet(path.Join("list", listID, "task", taskID), &task)
return &task, err
}
func (a *Ajax) storageSetTask(listID, taskID string, newTask *task.Task) error {
func (a *Ajax) storageSetTask(listID string, newTask *task.Task) error {
if newTask == nil {
newTask = &task.Task{}
newTask = &task.Task{
UUID: "nil",
}
return a.storageSet(path.Join(listID, taskID), *newTask)
}
if err := a.storageSet(path.Join("task", newTask.UUID, "map"), listID); err != nil {
return err
}
return a.storageSet(path.Join("list", listID, "task", newTask.UUID), *newTask)
}
func (a *Ajax) storageDelTask(listID, taskID string) error {
return a.storageDel(path.Join(listID, taskID))
func (a *Ajax) storageDelTask(taskID string) error {
var listID string
if err := a.storageGet(path.Join("task", taskID, "map"), &listID); err != nil {
return err
}
if err := a.storageDel(path.Join("task", taskID, "map")); err != nil {
return err
}
return a.storageDel(path.Join("list", listID, "task", taskID))
}
func (a *Ajax) storageGetList(listID string) (*list.List, error) {
listID = strings.TrimSuffix(listID, "/") + "/"
var list list.List
err := a.storageGet(listID, &list)
err := a.storageGet(path.Join("list", listID), &list)
return &list, err
}
func (a *Ajax) storageSetList(listID string, list *list.List) error {
return a.storageSet(listID, *list)
func (a *Ajax) storageSetList(list *list.List) error {
return a.storageSet(path.Join("list", list.UUID), *list)
}
func (a *Ajax) storageDelList(listID string) error {
return a.storageDel(listID)
}
func (a *Ajax) storageSetCurTags(tags []string) error {
return a.storageSet("currentTags", tags)
}
func (a *Ajax) storageGetCurTags() ([]string, error) {
var tags []string
err := a.storageGet("currentTags", &tags)
return tags, err
}
func (a *Ajax) storageSetCur(listID string) error {
return a.storageSet("currentList", listID)
}
func (a *Ajax) storageGetCur() (string, error) {
var listID string
err := a.storageGet("currentList", &listID)
return listID, err
listID = strings.TrimSuffix(listID, "/") + "/"
return a.storageDel(path.Join("list", listID))
}
func (a *Ajax) storageSet(key string, value interface{}) error {

56
server/ajax/storage_test.go
View File

@ -1,6 +1,7 @@
package ajax
import (
"local/todo-server/server/ajax/list"
"local/todo-server/server/ajax/task"
"net/http/httptest"
"testing"
@ -21,11 +22,33 @@ func TestAjaxStorageCur(t *testing.T) {
}
}
func TestAjaxStorageListLists(t *testing.T) {
ajax := mockAjax()
ajax.storageSetList(&list.List{UUID: "b", Name: "x"})
ajax.storageSetList(&list.List{UUID: "c", Name: "y"})
ajax.storageSetList(&list.List{UUID: "d", Name: "z"})
filter := func(list *list.List) bool {
return list.Name == "x" || list.Name == "y"
}
if results, err := ajax.storageListLists(); err != nil {
t.Error(err)
} else if len(results) != 3 {
t.Error(results)
}
if results, err := ajax.storageListLists(filter); err != nil {
t.Error(err)
} else if len(results) != 2 {
t.Error(results)
}
}
func TestAjaxStorageListTasks(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("a", "b", &task.Task{Title: "x"})
ajax.storageSetTask("a", "c", &task.Task{Title: "y"})
ajax.storageSetTask("a", "d", &task.Task{Title: "z"})
ajax.storageSetTask("a", &task.Task{UUID: "b", Title: "x"})
ajax.storageSetTask("a", &task.Task{UUID: "c", Title: "y"})
ajax.storageSetTask("a", &task.Task{UUID: "d", Title: "z"})
filter := func(task *task.Task) bool {
return task.Title == "x" || task.Title == "y"
}
@ -45,17 +68,34 @@ func TestAjaxStorageListTasks(t *testing.T) {
func TestAjaxStorageGetSetDelTask(t *testing.T) {
ajax := mockAjax()
if _, err := ajax.storageGetTask("a", "b"); err == nil {
if _, err := ajax.storageGetTask("b"); err == nil {
t.Error(err)
} else if err := ajax.storageSetTask("a", "b", &task.Task{Title: "c"}); err != nil {
} else if err := ajax.storageSetTask("a", &task.Task{UUID: "b", Title: "c"}); err != nil {
t.Error(err)
} else if task, err := ajax.storageGetTask("a", "b"); err != nil {
} else if task, err := ajax.storageGetTask("b"); err != nil {
t.Error(err)
} else if task.Title != "c" {
t.Error(err)
} else if err := ajax.storageDelTask("a", "b"); err != nil {
} else if err := ajax.storageDelTask("b"); err != nil {
t.Error(err)
} else if _, err := ajax.storageGetTask("a", "b"); err == nil {
} else if _, err := ajax.storageGetTask("b"); err == nil {
t.Error(err)
}
}
func TestAjaxStorageGetSetDelList(t *testing.T) {
ajax := mockAjax()
if _, err := ajax.storageGetList("a"); err == nil {
t.Error(err)
} else if err := ajax.storageSetList(&list.List{UUID: "a", Name: "b"}); err != nil {
t.Error(err)
} else if List, err := ajax.storageGetList("a"); err != nil {
t.Error(err)
} else if List.Name != "b" {
t.Error(err)
} else if err := ajax.storageDelList("a"); err != nil {
t.Error(err)
} else if _, err := ajax.storageGetList("a"); err == nil {
t.Error(err)
}
}

56
server/ajax/task.go
View File

@ -53,34 +53,9 @@ func (a *Ajax) newTask(w http.ResponseWriter, r *http.Request) error {
if err != nil {
return err
}
if err := a.storageSetTask(listID, newTask.UUID, newTask); err != nil {
if err := a.storageSetTask(listID, newTask); err != nil {
return err
}
// {"total":4,"list":[
// {"id":"3455",
// "title":"redo qvolution",
// "listId":"18",
// "date":"14 Oct 2019 12:56 PM",
// "dateInt":1571079392,
// "dateInline":"14 Oct",
// "dateInlineTitle":"created at 14 Oct 2019 12:56 PM",
// "dateEditedInt":1571079401,
// "dateCompleted":"",
// "dateCompletedInline":"",
// "dateCompletedInlineTitle":"Completed at ",
// "compl":0,
// "prio":"0",
// "note":"",
// "noteText":"",
// "ow":4,
// "tags":"work",
// "tags_ids":"138",
// "duedate":"",
// "dueClass":"",
// "dueStr":"",
// "dueInt":33330000,
// "dueTitle":"Due "}
// ]}
return json.NewEncoder(w).Encode(map[string]interface{}{
"total": 1,
"list": []*task.Task{newTask},
@ -98,28 +73,28 @@ func (a *Ajax) makeTask(r *http.Request) (string, *task.Task, error) {
}
func (a *Ajax) deleteTask(w http.ResponseWriter, r *http.Request) error {
listID, taskID, _ := a.Cur(r)
return a.storageDelTask(listID, taskID)
_, taskID, _ := a.Cur(r)
return a.storageDelTask(taskID)
}
func (a *Ajax) completeTask(w http.ResponseWriter, r *http.Request) error {
listID, taskID, _ := a.Cur(r)
task, err := a.storageGetTask(listID, taskID)
task, err := a.storageGetTask(taskID)
if err != nil {
return err
}
task.SetComplete(form.Get(r, "compl") == "1")
return a.storageSetTask(listID, taskID, task)
return a.storageSetTask(listID, task)
}
func (a *Ajax) editNote(w http.ResponseWriter, r *http.Request) error {
listID, taskID, _ := a.Cur(r)
task, err := a.storageGetTask(listID, taskID)
task, err := a.storageGetTask(taskID)
if err != nil {
return err
}
task.SetNote(form.Get(r, "note"))
return a.storageSetTask(listID, taskID, task)
return a.storageSetTask(listID, task)
}
func (a *Ajax) editTask(w http.ResponseWriter, r *http.Request) error {
@ -129,29 +104,30 @@ func (a *Ajax) editTask(w http.ResponseWriter, r *http.Request) error {
}
_, taskID, _ := a.Cur(r)
task.UUID = taskID
task.ID = task.UUID
return a.storageSetTask(listID, task.UUID, task)
return a.storageSetTask(listID, task)
}
func (a *Ajax) setPrio(w http.ResponseWriter, r *http.Request) error {
listID, taskID, _ := a.Cur(r)
task, err := a.storageGetTask(listID, taskID)
task, err := a.storageGetTask(taskID)
if err != nil {
return err
}
task.SetPrio(form.ToInt(form.Get(r, "prio")))
return a.storageSetTask(listID, taskID, task)
return a.storageSetTask(listID, task)
}
func (a *Ajax) moveTask(w http.ResponseWriter, r *http.Request) error {
listID, taskID, _ := a.Cur(r)
_, taskID, _ := a.Cur(r)
toList := form.Get(r, "to")
task, err := a.storageGetTask(listID, taskID)
task, err := a.storageGetTask(taskID)
if err != nil {
return err
}
a.storageDelTask(listID, taskID)
return a.storageSetTask(toList, taskID, task)
if err := a.storageDelTask(taskID); err != nil {
return err
}
return a.storageSetTask(toList, task)
}
func (a *Ajax) parseTaskStr(w http.ResponseWriter, r *http.Request) error {

6
server/ajax/task/task.go
View File

@ -9,12 +9,9 @@ import (
"regexp"
"strings"
"time"
"github.com/google/uuid"
)
type Task struct {
ID string
UUID string
Title string
Priority int
@ -37,7 +34,7 @@ func (sl StrList) MarshalJSON() ([]byte, error) {
func New(r *http.Request) (*Task, error) {
task := &Task{
UUID: uuid.New().String(),
UUID: form.NewUUID(),
Title: form.Get(r, "title"),
Priority: form.ToInt(form.Get(r, "prio")),
Tags: StrList(form.ToStrArr(form.Get(r, "tags"))),
@ -46,7 +43,6 @@ func New(r *http.Request) (*Task, error) {
Due: form.ToTime(form.Get(r, "duedate")),
}
task.ID = task.UUID
task.SetNote(form.Get(r, "note"))
return task, task.validate()
}

28
server/ajax/task_test.go
View File

@ -5,6 +5,7 @@ import (
"local/todo-server/server/ajax/task"
"net/http"
"net/http/httptest"
"path"
"strings"
"testing"
)
@ -28,7 +29,7 @@ func TestAjaxLoadTasks(t *testing.T) {
}
}()
a.storageSetTask("list", "task", &task.Task{Title: "hi"})
a.storageSetTask("list", &task.Task{UUID: "task", Title: "hi"})
func() {
w := httptest.NewRecorder()
@ -85,7 +86,7 @@ func TestAjaxMakeTask(t *testing.T) {
func TestAjaxDeleteTask(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("list", "b", &task.Task{Title: "c"})
ajax.storageSetTask("list", &task.Task{UUID: "b", Title: "c"})
w := httptest.NewRecorder()
r := httptest.NewRequest("GET", "/?id=b&list=list", nil)
ajax.deleteTask(w, r)
@ -99,14 +100,14 @@ func TestAjaxDeleteTask(t *testing.T) {
if len(results) != 0 {
t.Error(results)
}
if _, err := ajax.storageGetTask("list", "b"); err == nil {
if _, err := ajax.storageGetTask("b"); err == nil {
t.Fatal(err)
}
}
func TestAjaxCompleteTask(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("list", "b", &task.Task{Title: "c"})
ajax.storageSetTask("list", &task.Task{UUID: "b", Title: "c"})
for _, state := range []string{"1", "0"} {
w := httptest.NewRecorder()
r := httptest.NewRequest("GET", "/?id=b&list=list&compl="+state, nil)
@ -114,7 +115,7 @@ func TestAjaxCompleteTask(t *testing.T) {
if v := w.Code; v != http.StatusOK {
t.Error(v)
}
if task, err := ajax.storageGetTask("list", "b"); err != nil {
if task, err := ajax.storageGetTask("b"); err != nil {
t.Fatal(err)
} else if task.Complete != (state == "1") {
t.Error(task)
@ -124,7 +125,7 @@ func TestAjaxCompleteTask(t *testing.T) {
func TestAjaxEditNote(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("list", "b", &task.Task{Title: "c", Note: []string{"hi", "mom"}})
ajax.storageSetTask("list", &task.Task{UUID: "b", Title: "c", Note: []string{"hi", "mom"}})
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/?id=b&list=list&compl=0", strings.NewReader(`{
"note":"hello world i like tacos"
@ -133,7 +134,7 @@ func TestAjaxEditNote(t *testing.T) {
if v := w.Code; v != http.StatusOK {
t.Error(v)
}
if task, err := ajax.storageGetTask("list", "b"); err != nil {
if task, err := ajax.storageGetTask("b"); err != nil {
t.Fatal(err)
} else if len(task.Note) != 1 {
t.Error(task.Note)
@ -142,7 +143,7 @@ func TestAjaxEditNote(t *testing.T) {
func TestAjaxEditTask(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("list", "b", &task.Task{Title: "c", Note: []string{"hi"}})
ajax.storageSetTask("list", &task.Task{UUID: "b", Title: "c", Note: []string{"hi"}})
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/?id=b&list=list&compl=0", strings.NewReader(`{
"title": "newtitle",
@ -152,7 +153,7 @@ func TestAjaxEditTask(t *testing.T) {
if v := w.Code; v != http.StatusOK {
t.Error(v)
}
if task, err := ajax.storageGetTask("list", "b"); err != nil {
if task, err := ajax.storageGetTask("b"); err != nil {
t.Fatal(err)
} else if task.Title != "newtitle" {
t.Error(task)
@ -161,17 +162,18 @@ func TestAjaxEditTask(t *testing.T) {
func TestAjaxMoveTask(t *testing.T) {
ajax := mockAjax()
ajax.storageSetTask("list", "b", &task.Task{Title: "c"})
ajax.storageSetTask("list", &task.Task{UUID: "b", Title: "c"})
w := httptest.NewRecorder()
r := httptest.NewRequest("GET", "/?id=b&list=list&to=listB", strings.NewReader(`{}`))
ajax.moveTask(w, r)
if v := w.Code; v != http.StatusOK {
t.Error(v)
}
if task, err := ajax.storageGetTask("list", "b"); err == nil {
t.Error(err, task)
var v interface{}
if err := ajax.storageGet(path.Join("list", "list", "task", "b"), &v); err == nil {
t.Error(err)
}
if task, err := ajax.storageGetTask("listB", "b"); err != nil {
if task, err := ajax.storageGetTask("b"); err != nil {
t.Error(err, task)
}
}