mirrors/homebox
1
0
Fork 1
mirror of https://github.com/hay-kot/homebox.git synced 2025-07-05 01:58:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

feat: locations tree viewer (#248)

Browse source 
* location tree API

* test fixes

* initial tree location elements

* locations tree page

* update meta-data

* code-gen

* store item display preferences

* introduce basic table/card view elements

* codegen

* set parent location during location creation

* add item support for tree query

* refactor tree view

* wip: location selector improvements

* type gen

* rename items -> search

* remove various log statements

* fix markdown rendering for description

* update location selectors

* fix tests

* fix currency tests

* formatting
This commit is contained in:
Hayden 2023-01-28 11:53:00 -09:00 • committed by GitHub
parent 4d220cdd9c
commit 3d295b5132
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
33 changed files with 1119 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

189
backend/internal/data/repo/repo_locations_test.go
View file

@ -2,8 +2,11 @@ package repo
import (
"context"
"encoding/json"
"testing"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/stretchr/testify/assert"
)
@ -14,6 +17,30 @@ func locationFactory() LocationCreate {
}
}
func useLocations(t *testing.T, len int) []LocationOut {
t.Helper()
out := make([]LocationOut, len)
for i := 0; i < len; i++ {
loc, err := tRepos.Locations.Create(context.Background(), tGroup.ID, locationFactory())
assert.NoError(t, err)
out[i] = loc
}
t.Cleanup(func() {
for _, loc := range out {
err := tRepos.Locations.Delete(context.Background(), loc.ID)
if err != nil {
assert.True(t, ent.IsNotFound(err))
}
}
})
return out
}
func TestLocationRepository_Get(t *testing.T) {
loc, err := tRepos.Locations.Create(context.Background(), tGroup.ID, locationFactory())
assert.NoError(t, err)
@ -29,13 +56,9 @@ func TestLocationRepository_Get(t *testing.T) {
func TestLocationRepositoryGetAllWithCount(t *testing.T) {
ctx := context.Background()
result, err := tRepos.Locations.Create(ctx, tGroup.ID, LocationCreate{
Name: fk.Str(10),
Description: fk.Str(100),
})
assert.NoError(t, err)
result := useLocations(t, 1)[0]
_, err = tRepos.Items.Create(ctx, tGroup.ID, ItemCreate{
_, err := tRepos.Items.Create(ctx, tGroup.ID, ItemCreate{
Name: fk.Str(10),
Description: fk.Str(100),
LocationID: result.ID,
@ -55,8 +78,7 @@ func TestLocationRepositoryGetAllWithCount(t *testing.T) {
}
func TestLocationRepository_Create(t *testing.T) {
loc, err := tRepos.Locations.Create(context.Background(), tGroup.ID, locationFactory())
assert.NoError(t, err)
loc := useLocations(t, 1)[0]
// Get by ID
foundLoc, err := tRepos.Locations.Get(context.Background(), loc.ID)
@ -68,8 +90,7 @@ func TestLocationRepository_Create(t *testing.T) {
}
func TestLocationRepository_Update(t *testing.T) {
loc, err := tRepos.Locations.Create(context.Background(), tGroup.ID, locationFactory())
assert.NoError(t, err)
loc := useLocations(t, 1)[0]
updateData := LocationUpdate{
ID: loc.ID,
@ -92,12 +113,154 @@ func TestLocationRepository_Update(t *testing.T) {
}
func TestLocationRepository_Delete(t *testing.T) {
loc, err := tRepos.Locations.Create(context.Background(), tGroup.ID, locationFactory())
assert.NoError(t, err)
loc := useLocations(t, 1)[0]
err = tRepos.Locations.Delete(context.Background(), loc.ID)
err := tRepos.Locations.Delete(context.Background(), loc.ID)
assert.NoError(t, err)
_, err = tRepos.Locations.Get(context.Background(), loc.ID)
assert.Error(t, err)
}
func TestItemRepository_TreeQuery(t *testing.T) {
locs := useLocations(t, 3)
// Set relations
_, err := tRepos.Locations.UpdateOneByGroup(context.Background(), tGroup.ID, locs[0].ID, LocationUpdate{
ID: locs[0].ID,
ParentID: locs[1].ID,
Name: locs[0].Name,
Description: locs[0].Description,
})
assert.NoError(t, err)
locations, err := tRepos.Locations.Tree(context.Background(), tGroup.ID, TreeQuery{WithItems: true})
assert.NoError(t, err)
assert.Equal(t, 2, len(locations))
// Check roots
for _, loc := range locations {
if loc.ID == locs[1].ID {
assert.Equal(t, 1, len(loc.Children))
}
}
}
func TestConvertLocationsToTree(t *testing.T) {
uuid1, uuid2, uuid3, uuid4 := uuid.New(), uuid.New(), uuid.New(), uuid.New()
testCases := []struct {
name string
locations []FlatTreeItem
expected []TreeItem
}{
{
name: "Convert locations to tree",
locations: []FlatTreeItem{
{
ID: uuid1,
Name: "Root1",
ParentID: uuid.Nil,
Level: 0,
},
{
ID: uuid2,
Name: "Child1",
ParentID: uuid1,
Level: 1,
},
{
ID: uuid3,
Name: "Child2",
ParentID: uuid1,
Level: 1,
},
},
expected: []TreeItem{
{
ID: uuid1,
Name: "Root1",
Children: []*TreeItem{
{
ID: uuid2,
Name: "Child1",
Children: []*TreeItem{},
},
{
ID: uuid3,
Name: "Child2",
Children: []*TreeItem{},
},
},
},
},
},
{
name: "Convert locations to tree with deeply nested children",
locations: []FlatTreeItem{
{
ID: uuid1,
Name: "Root1",
ParentID: uuid.Nil,
Level: 0,
},
{
ID: uuid2,
Name: "Child1",
ParentID: uuid1,
Level: 1,
},
{
ID: uuid3,
Name: "Child2",
ParentID: uuid2,
Level: 2,
},
{
ID: uuid4,
Name: "Child3",
ParentID: uuid3,
Level: 3,
},
},
expected: []TreeItem{
{
ID: uuid1,
Name: "Root1",
Children: []*TreeItem{
{
ID: uuid2,
Name: "Child1",
Children: []*TreeItem{
{
ID: uuid3,
Name: "Child2",
Children: []*TreeItem{
{
ID: uuid4,
Name: "Child3",
Children: []*TreeItem{},
},
},
},
},
},
},
},
},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
result := ConvertLocationsToTree(tc.locations)
// Compare JSON strings
expected, _ := json.Marshal(tc.expected)
got, _ := json.Marshal(result)
assert.Equal(t, string(expected), string(got))
})
}
}