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

server/ajax/ajax_test.go

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

server/ajax/form/uuid.go

@@ -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())
+}

server/ajax/form/uuid_test.go

@@ -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{}{}
+	}
+}

server/ajax/list.go

@@ -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}]}
+	newList, err := list.New(r)
-	return errors.New("not impl")
+	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 {

server/ajax/list/list.go

@@ -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 {
+func (l *List) SetName(name string) {
-	return errors.New("not impl")
+	l.Name = name
 }
 
-func (l *List) changeOrder() error {
+func (l *List) SetPublished(state bool) {
-	return errors.New("not impl")
+	set(state, &l.Published)
 }
 
-func (l *List) addList() error {
+func (l *List) SetShowCompl(state bool) {
-	return errors.New("not impl")
+	set(state, &l.ShowCompl)
 }
 
-func (l *List) renameList() error {
+func (l *List) SetShowNotes(state bool) {
-	return errors.New("not impl")
+	set(state, &l.ShowNotes)
 }
 
-func (l *List) deleteList() error {
+func (l *List) SetHideList(state bool) {
-	return errors.New("not impl")
+	set(state, &l.Hidden)
 }
 
-func (l *List) setSort() error {
+func set(b bool, i *int) {
-	return errors.New("not impl")
+	*i = 1
-}
+	if !b {
-
+		*i = 0
-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")
 }

server/ajax/list_test.go

@@ -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
+}

server/ajax/storage.go

@@ -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{
+		list, err := a.storageGetList(path.Base(result))
-			ID:   result,
+		if err != nil {
-			UUID: result,
+			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+"/")
+		taskID := path.Base(result)
-		task, err := a.storageGetTask(listID, taskID)
+		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 {
+func (a *Ajax) storageDelTask(taskID string) error {
-	return a.storageDel(path.Join(listID, taskID))
+	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 {
+func (a *Ajax) storageSetList(list *list.List) error {
-	return a.storageSet(listID, *list)
+	return a.storageSet(path.Join("list", list.UUID), *list)
 }
 
 func (a *Ajax) storageDelList(listID string) error {
-	return a.storageDel(listID)
+	listID = strings.TrimSuffix(listID, "/") + "/"
-}
+	return a.storageDel(path.Join("list", 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
 }
 
 func (a *Ajax) storageSet(key string, value interface{}) error {

server/ajax/storage_test.go

@@ -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", &task.Task{UUID: "b", Title: "x"})
-	ajax.storageSetTask("a", "c", &task.Task{Title: "y"})
+	ajax.storageSetTask("a", &task.Task{UUID: "c", Title: "y"})
-	ajax.storageSetTask("a", "d", &task.Task{Title: "z"})
+	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)
 	}
 }

server/ajax/task.go

@@ -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)
+	_, taskID, _ := a.Cur(r)
-	return a.storageDelTask(listID, taskID)
+	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)
-	return a.storageSetTask(listID, task.UUID, 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)
+	if err := a.storageDelTask(taskID); err != nil {
-	return a.storageSetTask(toList, taskID, task)
+		return err
+	}
+	return a.storageSetTask(toList, task)
 }
 
 func (a *Ajax) parseTaskStr(w http.ResponseWriter, r *http.Request) error {

server/ajax/task/task.go

@@ -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()
 }

server/ajax/task_test.go

@@ -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 {
+	var v interface{}
-		t.Error(err, task)
+	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)
 	}
 }