380 lines
12 KiB
Go
380 lines
12 KiB
Go
// Vikunja is a to-do list application to facilitate your life.
|
|
// Copyright 2018-present Vikunja and contributors. All rights reserved.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package wekan
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestConvertWekanToVikunja(t *testing.T) {
|
|
startDate := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
|
|
dueDate := time.Date(2024, 2, 15, 10, 0, 0, 0, time.UTC)
|
|
createdAt := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
commentDate := time.Date(2024, 1, 20, 14, 30, 0, 0, time.UTC)
|
|
|
|
board := &wekanBoard{
|
|
ID: "board1",
|
|
Title: "My Board",
|
|
Labels: []wekanLabel{
|
|
{ID: "lbl1", Name: "Bug", Color: "red"},
|
|
{ID: "lbl2", Name: "Feature", Color: "green"},
|
|
{ID: "lbl3", Name: "", Color: "blue"},
|
|
},
|
|
Lists: []wekanList{
|
|
{ID: "list1", Title: "To Do", Sort: 1},
|
|
{ID: "list2", Title: "In Progress", Sort: 2},
|
|
},
|
|
Cards: []wekanCard{
|
|
{
|
|
ID: "card1",
|
|
Title: "Fix login bug",
|
|
Description: "The login page crashes",
|
|
ListID: "list1",
|
|
LabelIDs: []string{"lbl1"},
|
|
Sort: 1,
|
|
StartAt: &startDate,
|
|
DueAt: &dueDate,
|
|
CreatedAt: &createdAt,
|
|
},
|
|
{
|
|
ID: "card2",
|
|
Title: "Add dashboard",
|
|
ListID: "list2",
|
|
LabelIDs: []string{"lbl2", "lbl3"},
|
|
Sort: 1,
|
|
},
|
|
{
|
|
ID: "card3",
|
|
Title: "Archived task",
|
|
ListID: "list1",
|
|
Sort: 2,
|
|
Archived: true,
|
|
},
|
|
},
|
|
Checklists: []wekanChecklist{
|
|
{ID: "cl1", CardID: "card1", Title: "Steps to reproduce", Sort: 1},
|
|
},
|
|
ChecklistItems: []wekanChecklistItem{
|
|
{ID: "cli1", ChecklistID: "cl1", CardID: "card1", Title: "Open browser", Sort: 1, IsFinished: true},
|
|
{ID: "cli2", ChecklistID: "cl1", CardID: "card1", Title: "Click login", Sort: 2, IsFinished: false},
|
|
},
|
|
Comments: []wekanComment{
|
|
{ID: "com1", Text: "This is urgent", CreatedAt: &commentDate, CardID: "card1"},
|
|
},
|
|
}
|
|
|
|
result := convertWekanToVikunja(board)
|
|
|
|
// Should have 1 project (the board itself)
|
|
require.Len(t, result, 1)
|
|
project := result[0]
|
|
|
|
assert.Equal(t, "My Board", project.Title)
|
|
|
|
// Should have 2 buckets (one per list)
|
|
require.Len(t, project.Buckets, 2)
|
|
assert.Equal(t, "To Do", project.Buckets[0].Title)
|
|
assert.Equal(t, "In Progress", project.Buckets[1].Title)
|
|
|
|
// Should have 3 tasks
|
|
require.Len(t, project.Tasks, 3)
|
|
|
|
// Task 1: Fix login bug
|
|
task1 := project.Tasks[0]
|
|
assert.Equal(t, "Fix login bug", task1.Title)
|
|
assert.Contains(t, task1.Description, "The login page crashes")
|
|
assert.Equal(t, startDate, task1.StartDate)
|
|
assert.Equal(t, dueDate, task1.DueDate)
|
|
// Should be in bucket 1 (To Do)
|
|
assert.Equal(t, int64(1), task1.BucketID)
|
|
|
|
// Labels on task 1
|
|
require.Len(t, task1.Labels, 1)
|
|
assert.Equal(t, "Bug", task1.Labels[0].Title)
|
|
assert.Equal(t, "eb4646", task1.Labels[0].HexColor) // red mapped
|
|
|
|
// Checklist should be appended to description as HTML task list
|
|
assert.Contains(t, task1.Description, "Steps to reproduce")
|
|
assert.Contains(t, task1.Description, "Open browser")
|
|
assert.Contains(t, task1.Description, "Click login")
|
|
assert.Contains(t, task1.Description, `checked="checked"`) // first item is done
|
|
|
|
// Comment on task 1 (markdown converted to HTML)
|
|
require.Len(t, task1.Comments, 1)
|
|
assert.Contains(t, task1.Comments[0].Comment, "This is urgent")
|
|
assert.Equal(t, commentDate, task1.Comments[0].Created)
|
|
|
|
// Task 2: Add dashboard
|
|
task2 := project.Tasks[1]
|
|
assert.Equal(t, "Add dashboard", task2.Title)
|
|
assert.Equal(t, int64(2), task2.BucketID) // In Progress
|
|
require.Len(t, task2.Labels, 2)
|
|
assert.Equal(t, "Feature", task2.Labels[0].Title)
|
|
assert.Equal(t, "3cb500", task2.Labels[0].HexColor) // green mapped
|
|
// Label with empty name but color "blue" should still be created with the color name as title
|
|
assert.Equal(t, "blue", task2.Labels[1].Title)
|
|
|
|
// Task 3: Archived → done
|
|
task3 := project.Tasks[2]
|
|
assert.Equal(t, "Archived task", task3.Title)
|
|
assert.True(t, task3.Done)
|
|
assert.Equal(t, int64(1), task3.BucketID) // To Do
|
|
}
|
|
|
|
func TestParseWekanJSON_ParsesAttachments(t *testing.T) {
|
|
raw := []byte(`{
|
|
"_id": "b1",
|
|
"title": "B",
|
|
"lists": [],
|
|
"cards": [],
|
|
"attachments": [
|
|
{"_id": "a1", "cardId": "c1", "file": "aGVsbG8=", "name": "hi.txt", "type": "text/plain"}
|
|
]
|
|
}`)
|
|
|
|
board, err := parseWekanJSON(bytes.NewReader(raw))
|
|
require.NoError(t, err)
|
|
require.Len(t, board.Attachments, 1)
|
|
assert.Equal(t, "a1", board.Attachments[0].ID)
|
|
assert.Equal(t, "c1", board.Attachments[0].CardID)
|
|
assert.Equal(t, "aGVsbG8=", board.Attachments[0].File)
|
|
assert.Equal(t, "hi.txt", board.Attachments[0].Name)
|
|
assert.Equal(t, "text/plain", board.Attachments[0].Type)
|
|
}
|
|
|
|
func TestConvertWekanToVikunja_Attachments(t *testing.T) {
|
|
// "hello" in base64 is "aGVsbG8="
|
|
board := &wekanBoard{
|
|
ID: "b1",
|
|
Title: "B",
|
|
Lists: []wekanList{{ID: "l1", Title: "L", Sort: 0}},
|
|
Cards: []wekanCard{{ID: "c1", Title: "Card", ListID: "l1"}},
|
|
Attachments: []wekanAttachment{
|
|
{ID: "a1", CardID: "c1", File: "aGVsbG8=", Name: "hi.txt", Type: "text/plain"},
|
|
{ID: "a2", CardID: "c1", File: "d29ybGQ=", Name: "w.txt", Type: "text/plain"},
|
|
{ID: "a3", CardID: "missing", File: "aGVsbG8=", Name: "orphan.txt", Type: "text/plain"},
|
|
},
|
|
}
|
|
|
|
projects := convertWekanToVikunja(board)
|
|
require.Len(t, projects, 1)
|
|
require.Len(t, projects[0].Tasks, 1)
|
|
|
|
task := projects[0].Tasks[0]
|
|
require.Len(t, task.Attachments, 2)
|
|
|
|
assert.Equal(t, "hi.txt", task.Attachments[0].File.Name)
|
|
assert.Equal(t, "text/plain", task.Attachments[0].File.Mime)
|
|
assert.Equal(t, []byte("hello"), task.Attachments[0].File.FileContent)
|
|
assert.Equal(t, uint64(5), task.Attachments[0].File.Size)
|
|
|
|
assert.Equal(t, "w.txt", task.Attachments[1].File.Name)
|
|
assert.Equal(t, []byte("world"), task.Attachments[1].File.FileContent)
|
|
}
|
|
|
|
func TestMigrateValidJSON(t *testing.T) {
|
|
validJSON := `{
|
|
"_id": "board1",
|
|
"title": "Test Board",
|
|
"labels": [{"_id": "l1", "name": "Bug", "color": "red"}],
|
|
"lists": [{"_id": "list1", "title": "To Do", "sort": 1}],
|
|
"cards": [{"_id": "c1", "title": "Task 1", "listId": "list1", "sort": 1, "labelIds": ["l1"]}],
|
|
"checklists": [],
|
|
"checklistItems": [],
|
|
"comments": []
|
|
}`
|
|
|
|
m := &Migrator{}
|
|
assert.Equal(t, "wekan", m.Name())
|
|
|
|
// Test that parsing works without error
|
|
r := bytes.NewReader([]byte(validJSON))
|
|
board, err := parseWekanJSON(r)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Test Board", board.Title)
|
|
require.Len(t, board.Cards, 1)
|
|
assert.Equal(t, "Task 1", board.Cards[0].Title)
|
|
}
|
|
|
|
func TestParseWekanJSONInvalid(t *testing.T) {
|
|
_, err := parseWekanJSON(bytes.NewReader([]byte("not json")))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestParseWekanJSONEmpty(t *testing.T) {
|
|
_, err := parseWekanJSON(bytes.NewReader([]byte("")))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestConvertWekanEmptyBoard(t *testing.T) {
|
|
board := &wekanBoard{
|
|
Title: "Empty Board",
|
|
}
|
|
|
|
result := convertWekanToVikunja(board)
|
|
require.Len(t, result, 1)
|
|
assert.Equal(t, "Empty Board", result[0].Title)
|
|
assert.Empty(t, result[0].Tasks)
|
|
assert.Empty(t, result[0].Buckets)
|
|
}
|
|
|
|
func TestConvertWekanCardWithoutList(t *testing.T) {
|
|
// Card references a list that doesn't exist
|
|
board := &wekanBoard{
|
|
Title: "Board",
|
|
Lists: []wekanList{{ID: "list1", Title: "To Do", Sort: 1}},
|
|
Cards: []wekanCard{
|
|
{ID: "c1", Title: "Orphan card", ListID: "nonexistent", Sort: 1},
|
|
{ID: "c2", Title: "Normal card", ListID: "list1", Sort: 2},
|
|
},
|
|
}
|
|
|
|
result := convertWekanToVikunja(board)
|
|
require.Len(t, result, 1)
|
|
// Orphan card should still be created, just with bucket ID 0
|
|
require.Len(t, result[0].Tasks, 2)
|
|
assert.Equal(t, int64(0), result[0].Tasks[0].BucketID)
|
|
assert.Equal(t, int64(1), result[0].Tasks[1].BucketID)
|
|
}
|
|
|
|
func TestConvertWekanLabelColorMapping(t *testing.T) {
|
|
board := &wekanBoard{
|
|
Title: "Board",
|
|
Labels: []wekanLabel{
|
|
{ID: "l1", Name: "Urgent", Color: "red"},
|
|
{ID: "l2", Name: "Nice", Color: "green"},
|
|
{ID: "l3", Name: "Unknown color", Color: "chartreuse"},
|
|
},
|
|
Lists: []wekanList{{ID: "list1", Title: "List", Sort: 1}},
|
|
Cards: []wekanCard{
|
|
{ID: "c1", Title: "Task", ListID: "list1", LabelIDs: []string{"l1", "l2", "l3"}, Sort: 1},
|
|
},
|
|
}
|
|
|
|
result := convertWekanToVikunja(board)
|
|
labels := result[0].Tasks[0].Labels
|
|
require.Len(t, labels, 3)
|
|
assert.Equal(t, "eb4646", labels[0].HexColor) // red
|
|
assert.Equal(t, "3cb500", labels[1].HexColor) // green
|
|
assert.Empty(t, labels[2].HexColor) // unknown color has no hex
|
|
}
|
|
|
|
func TestConvertWekanMultipleChecklists(t *testing.T) {
|
|
board := &wekanBoard{
|
|
Title: "Board",
|
|
Lists: []wekanList{{ID: "list1", Title: "List", Sort: 1}},
|
|
Cards: []wekanCard{{ID: "c1", Title: "Task", ListID: "list1", Sort: 1}},
|
|
Checklists: []wekanChecklist{
|
|
{ID: "cl1", CardID: "c1", Title: "Checklist A", Sort: 1},
|
|
{ID: "cl2", CardID: "c1", Title: "Checklist B", Sort: 2},
|
|
},
|
|
ChecklistItems: []wekanChecklistItem{
|
|
{ID: "i1", ChecklistID: "cl1", CardID: "c1", Title: "Item A1", Sort: 1, IsFinished: false},
|
|
{ID: "i2", ChecklistID: "cl2", CardID: "c1", Title: "Item B1", Sort: 1, IsFinished: true},
|
|
},
|
|
}
|
|
|
|
result := convertWekanToVikunja(board)
|
|
desc := result[0].Tasks[0].Description
|
|
assert.Contains(t, desc, "Checklist A")
|
|
assert.Contains(t, desc, "Checklist B")
|
|
assert.Contains(t, desc, "Item A1")
|
|
assert.Contains(t, desc, "Item B1")
|
|
}
|
|
|
|
func TestParseWekanUnsupportedFieldsIgnored(t *testing.T) {
|
|
// WeKan exports include fields we don't import (swimlanes, activities, rules, etc.).
|
|
// Verify they are silently ignored and parsing succeeds.
|
|
jsonWithExtras := `{
|
|
"_id": "board1",
|
|
"title": "Board With Extras",
|
|
"labels": [],
|
|
"lists": [{"_id": "list1", "title": "List", "sort": 1}],
|
|
"cards": [{"_id": "c1", "title": "Task", "listId": "list1", "sort": 1}],
|
|
"checklists": [],
|
|
"checklistItems": [],
|
|
"comments": [],
|
|
"swimlanes": [{"_id": "sw1", "title": "Default"}],
|
|
"activities": [{"_id": "act1", "activityType": "addComment"}],
|
|
"rules": [{"_id": "rule1", "title": "Auto move"}],
|
|
"triggers": [{"_id": "trig1", "activityType": "cardMove"}],
|
|
"actions": [{"_id": "action1", "actionType": "moveCard"}],
|
|
"customFields": [{"_id": "cf1", "name": "Priority", "type": "text"}]
|
|
}`
|
|
|
|
board, err := parseWekanJSON(bytes.NewReader([]byte(jsonWithExtras)))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Board With Extras", board.Title)
|
|
require.Len(t, board.Cards, 1)
|
|
assert.Equal(t, "Task", board.Cards[0].Title)
|
|
|
|
// Conversion should also work fine
|
|
result := convertWekanToVikunja(board)
|
|
require.Len(t, result, 1)
|
|
assert.Equal(t, "Board With Extras", result[0].Title)
|
|
require.Len(t, result[0].Tasks, 1)
|
|
}
|
|
|
|
func TestConvertWekanFromFixtureFile(t *testing.T) {
|
|
file, err := os.Open("testdata_wekan_export.json")
|
|
require.NoError(t, err)
|
|
defer file.Close()
|
|
|
|
board, err := parseWekanJSON(file)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Sample Project Board", board.Title)
|
|
|
|
result := convertWekanToVikunja(board)
|
|
require.Len(t, result, 1)
|
|
project := result[0]
|
|
|
|
assert.Equal(t, "Sample Project Board", project.Title)
|
|
require.Len(t, project.Buckets, 3)
|
|
assert.Equal(t, "Backlog", project.Buckets[0].Title)
|
|
assert.Equal(t, "In Progress", project.Buckets[1].Title)
|
|
assert.Equal(t, "Done", project.Buckets[2].Title)
|
|
|
|
require.Len(t, project.Tasks, 3)
|
|
|
|
// Card 1 - has labels, checklist, comment, dates
|
|
task1 := project.Tasks[0]
|
|
assert.Equal(t, "Fix authentication flow", task1.Title)
|
|
assert.Contains(t, task1.Description, "Users are getting logged out")
|
|
assert.Contains(t, task1.Description, "Steps")
|
|
assert.Contains(t, task1.Description, "Reproduce the issue")
|
|
require.Len(t, task1.Labels, 2)
|
|
require.Len(t, task1.Comments, 1)
|
|
assert.False(t, task1.Done)
|
|
|
|
// Attachment on card 1
|
|
require.Len(t, task1.Attachments, 1)
|
|
assert.Equal(t, "note.txt", task1.Attachments[0].File.Name)
|
|
assert.Equal(t, "text/plain", task1.Attachments[0].File.Mime)
|
|
assert.Equal(t, []byte("hello wekan"), task1.Attachments[0].File.FileContent)
|
|
|
|
// Card 3 - archived
|
|
task3 := project.Tasks[2]
|
|
assert.Equal(t, "Update README", task3.Title)
|
|
assert.True(t, task3.Done)
|
|
}
|