diff --git a/.kiro/specs/custom-start-page/tasks.md b/.kiro/specs/custom-start-page/tasks.md index e2b9d8a..10edeec 100644 --- a/.kiro/specs/custom-start-page/tasks.md +++ b/.kiro/specs/custom-start-page/tasks.md @@ -110,7 +110,7 @@ Each task references specific requirements from the requirements document and in - **Validates: Requirements 8.2, 8.3, 8.4, 8.5** - [ ] 4. Implement page management - - [~] 4.1 Create PageService with all CRUD operations + - [x] 4.1 Create PageService with all CRUD operations - Implement GetPages method (query by user_id, sort by order) - Implement CreatePage method with default "Home" page for new users - Implement UpdatePage method (name and order updates) @@ -119,7 +119,7 @@ Each task references specific requirements from the requirements document and in - Add validation: prevent deletion of last page - _Requirements: 2.1, 2.2, 2.3, 2.5, 2.6, 2.7, 2.8_ - - [~] 4.2 Create page HTTP endpoints + - [x] 4.2 Create page HTTP endpoints - Implement GET /dashboard (full page with page tabs) - Implement GET /pages/:id (returns widget grid HTML fragment) - Implement POST /pages (create page, returns updated tabs HTML) diff --git a/cmd/server/main.go b/cmd/server/main.go index bc09a6a..5543889 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -9,6 +9,7 @@ import ( "custom-start-page/internal/auth" "custom-start-page/internal/handlers" "custom-start-page/internal/middleware" + "custom-start-page/internal/services" "custom-start-page/internal/storage" "custom-start-page/pkg/config" ) @@ -37,9 +38,22 @@ func main() { log.Fatalf("Failed to create Users table: %v", err) } + // Create Pages table if it doesn't exist + if err := dbClient.CreatePagesTable(ctx); err != nil { + log.Fatalf("Failed to create Pages table: %v", err) + } + + // Create Widgets table if it doesn't exist + if err := dbClient.CreateWidgetsTable(ctx); err != nil { + log.Fatalf("Failed to create Widgets table: %v", err) + } + // Initialize repositories userRepo := storage.NewUserRepository(dbClient, "Users") + // Initialize services + pageService := services.NewPageService(dbClient) + // Initialize auth services stateStore := auth.NewMemoryStateStore() oauthService := auth.NewOAuthService( @@ -53,7 +67,8 @@ func main() { // Initialize handlers authHandler := handlers.NewAuthHandler(oauthService, userService, sessionStore) - dashboardHandler := handlers.NewDashboardHandler() + dashboardHandler := handlers.NewDashboardHandler(pageService) + pageHandler := handlers.NewPageHandler(pageService) // Setup routes mux := http.NewServeMux() @@ -90,6 +105,13 @@ func main() { // Protected dashboard route mux.Handle("GET /dashboard", requireAuth(http.HandlerFunc(dashboardHandler.HandleDashboard))) + // Protected page routes + mux.Handle("GET /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleGetPage))) + mux.Handle("POST /pages", requireAuth(http.HandlerFunc(pageHandler.HandleCreatePage))) + mux.Handle("PUT /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleUpdatePage))) + mux.Handle("DELETE /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleDeletePage))) + mux.Handle("POST /pages/reorder", requireAuth(http.HandlerFunc(pageHandler.HandleReorderPages))) + // Start server addr := fmt.Sprintf("%s:%s", cfg.Server.Host, cfg.Server.Port) log.Printf("Starting server on %s", addr) diff --git a/docs/task-4.1-implementation.md b/docs/task-4.1-implementation.md new file mode 100644 index 0000000..2f0afbd --- /dev/null +++ b/docs/task-4.1-implementation.md @@ -0,0 +1,134 @@ +# Task 4.1 Implementation: PageService with CRUD Operations + +## Overview +Implemented the PageService with all required CRUD operations for managing user pages in the Custom Start Page application. + +## Implementation Details + +### File: `internal/services/page_service.go` + +#### Methods Implemented + +1. **GetPages(ctx, userID) ([]*Page, error)** + - Queries all pages for a user from DynamoDB + - Sorts pages by their order field + - Returns pages in display order + +2. **CreatePage(ctx, userID, name) (*Page, error)** + - Creates a new page with a unique UUID + - Automatically assigns the next order number + - Sets timestamps (CreatedAt, UpdatedAt) + - Persists to DynamoDB Pages table + +3. **CreateDefaultPage(ctx, userID) (*Page, error)** + - Creates the default "Home" page for new users + - Wrapper around CreatePage with "Home" as the name + - Satisfies Requirement 2.1 + +4. **UpdatePage(ctx, userID, pageID, name) (*Page, error)** + - Updates a page's name + - Updates the UpdatedAt timestamp + - Returns the updated page + - Uses DynamoDB UpdateItem with ReturnValues + +5. **DeletePage(ctx, userID, pageID) error** + - Validates that it's not the last page (prevents deletion) + - Queries all widgets associated with the page + - Cascade deletes all widgets in batches of 25 (DynamoDB limit) + - Deletes the page itself + - Satisfies Requirements 2.5, 2.6 + +6. **ReorderPages(ctx, userID, pageOrder) error** + - Validates all page IDs exist and belong to the user + - Validates the order list length matches existing pages + - Updates each page's order field atomically + - Updates timestamps + - Satisfies Requirement 2.7 + +#### Helper Functions + +- **sortPagesByOrder(pages)**: In-place bubble sort for pages by order field + +## Requirements Satisfied + +- ✅ **Requirement 2.1**: Default "Home" page creation for new users +- ✅ **Requirement 2.2**: Page creation with name prompt +- ✅ **Requirement 2.3**: Page name updates +- ✅ **Requirement 2.5**: Page deletion with cascade delete of widgets +- ✅ **Requirement 2.6**: Prevention of last page deletion +- ✅ **Requirement 2.7**: Page reordering with persistence +- ✅ **Requirement 2.8**: Immediate persistence to storage + +## Testing + +### Unit Tests (`internal/services/page_service_test.go`) + +Comprehensive test coverage including: + +1. **TestCreateDefaultPage**: Verifies default "Home" page creation +2. **TestGetPages**: Tests retrieving and sorting multiple pages +3. **TestGetPagesEmptyResult**: Tests empty result handling +4. **TestCreatePage**: Tests page creation with auto-incrementing order +5. **TestUpdatePage**: Tests page name updates +6. **TestDeletePage**: Tests page deletion +7. **TestDeleteLastPagePrevention**: Validates last page deletion prevention +8. **TestDeletePageWithWidgets**: Tests cascade deletion of widgets +9. **TestReorderPages**: Tests page reordering +10. **TestReorderPagesInvalidLength**: Tests validation of order list length +11. **TestReorderPagesInvalidPageID**: Tests validation of page IDs +12. **TestReorderPagesPersistence**: Tests persistence of reordered pages + +### Unit Tests Without DynamoDB (`internal/services/page_service_unit_test.go`) + +Tests that don't require DynamoDB: + +1. **TestSortPagesByOrder**: Tests sorting function +2. **TestSortPagesByOrderAlreadySorted**: Tests already sorted pages +3. **TestSortPagesByOrderReversed**: Tests reversed pages +4. **TestSortPagesByOrderEmpty**: Tests empty slice +5. **TestSortPagesByOrderSingle**: Tests single page + +**Status**: All unit tests pass ✅ + +## Key Design Decisions + +1. **Cascade Deletion**: When a page is deleted, all associated widgets are automatically deleted to maintain data integrity. + +2. **Last Page Protection**: The service prevents deletion of the last page to ensure users always have at least one page. + +3. **Batch Operations**: Widget deletion uses DynamoDB BatchWriteItem with batches of 25 items to handle pages with many widgets efficiently. + +4. **Order Management**: Pages maintain an order field that determines display sequence. The CreatePage method automatically assigns the next available order number. + +5. **Validation**: ReorderPages validates that all page IDs exist and belong to the user before making any changes. + +6. **Atomic Updates**: Each page update is atomic, ensuring consistency even with concurrent operations. + +## Dependencies + +- `github.com/aws/aws-sdk-go-v2`: AWS SDK for DynamoDB operations +- `github.com/google/uuid`: UUID generation for page IDs +- `github.com/stretchr/testify`: Testing assertions + +## Integration Points + +- **Storage Layer**: Uses `internal/storage/DynamoDBClient` for all database operations +- **Models**: Uses `internal/models.Page` and `internal/models.Widget` data structures +- **Future Integration**: Will be used by HTTP handlers in `internal/handlers` for page management endpoints + +## Notes + +- Tests require DynamoDB local running on `http://localhost:8000` +- AWS credentials must be configured (can be dummy credentials for local testing) +- The service is stateless and thread-safe +- All operations use context for cancellation and timeout support + +## Next Steps + +Task 4.2 will implement the HTTP endpoints that use this service: +- GET /dashboard +- GET /pages/:id +- POST /pages +- PUT /pages/:id +- DELETE /pages/:id +- POST /pages/reorder diff --git a/go.mod b/go.mod index 30ac60f..bc00b5b 100644 --- a/go.mod +++ b/go.mod @@ -8,7 +8,10 @@ require ( github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue v1.12.13 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.26.7 github.com/google/uuid v1.5.0 + github.com/gorilla/sessions v1.4.0 github.com/leanovate/gopter v0.2.11 + github.com/stretchr/testify v1.11.1 + golang.org/x/oauth2 v0.35.0 ) require ( @@ -26,9 +29,10 @@ require ( github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 // indirect github.com/aws/smithy-go v1.19.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/gorilla/securecookie v1.1.2 // indirect - github.com/gorilla/sessions v1.4.0 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect - golang.org/x/oauth2 v0.35.0 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect golang.org/x/sys v0.35.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/internal/handlers/dashboard_handler.go b/internal/handlers/dashboard_handler.go index 272b6fa..4f17a10 100644 --- a/internal/handlers/dashboard_handler.go +++ b/internal/handlers/dashboard_handler.go @@ -7,21 +7,26 @@ import ( "path/filepath" "custom-start-page/internal/middleware" + "custom-start-page/internal/models" + "custom-start-page/internal/services" ) // DashboardHandler handles dashboard-related HTTP requests type DashboardHandler struct { - templates *template.Template + pageService services.PageServiceInterface + templates *template.Template } // NewDashboardHandler creates a new dashboard handler -func NewDashboardHandler() *DashboardHandler { +func NewDashboardHandler(pageService services.PageServiceInterface) *DashboardHandler { // Parse templates templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html"))) template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html"))) + template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html"))) return &DashboardHandler{ - templates: templates, + pageService: pageService, + templates: templates, } } @@ -35,14 +40,23 @@ func (h *DashboardHandler) HandleDashboard(w http.ResponseWriter, r *http.Reques return } - // TODO: Fetch user's pages from database - // For now, we'll use mock data - pages := []map[string]interface{}{ - { - "ID": "default-page", - "Name": "Home", - "Active": true, - }, + // Fetch user's pages from database + pages, err := h.pageService.GetPages(r.Context(), userID) + if err != nil { + log.Printf("Failed to get pages: %v", err) + http.Error(w, "Failed to load pages", http.StatusInternalServerError) + return + } + + // If user has no pages, create default "Home" page + if len(pages) == 0 { + defaultPage, err := h.pageService.CreateDefaultPage(r.Context(), userID) + if err != nil { + log.Printf("Failed to create default page: %v", err) + http.Error(w, "Failed to create default page", http.StatusInternalServerError) + return + } + pages = []*models.Page{defaultPage} } // Render dashboard template diff --git a/internal/handlers/dashboard_handler_test.go b/internal/handlers/dashboard_handler_test.go index 31241f2..15f789c 100644 --- a/internal/handlers/dashboard_handler_test.go +++ b/internal/handlers/dashboard_handler_test.go @@ -6,10 +6,67 @@ import ( "net/http" "net/http/httptest" "testing" + "time" "custom-start-page/internal/middleware" + "custom-start-page/internal/models" ) +// mockPageService is a mock implementation of PageService for testing +type mockPageService struct { + pages []*models.Page + err error +} + +func (m *mockPageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) { + if m.err != nil { + return nil, m.err + } + return m.pages, nil +} + +func (m *mockPageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) { + if m.err != nil { + return nil, m.err + } + page := &models.Page{ + ID: "new-page-id", + UserID: userID, + Name: name, + Order: len(m.pages), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + m.pages = append(m.pages, page) + return page, nil +} + +func (m *mockPageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) { + return m.CreatePage(ctx, userID, "Home") +} + +func (m *mockPageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) { + if m.err != nil { + return nil, m.err + } + for _, page := range m.pages { + if page.ID == pageID && page.UserID == userID { + page.Name = name + page.UpdatedAt = time.Now() + return page, nil + } + } + return nil, nil +} + +func (m *mockPageService) DeletePage(ctx context.Context, userID, pageID string) error { + return m.err +} + +func (m *mockPageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error { + return m.err +} + // createMockDashboardTemplate creates a simple mock template for testing func createMockDashboardTemplate() *template.Template { tmpl := template.New("dashboard.html") @@ -21,8 +78,21 @@ func createMockDashboardTemplate() *template.Template { func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) { // Setup mockTemplate := createMockDashboardTemplate() + mockPages := []*models.Page{ + { + ID: "page-1", + UserID: "test-user-123", + Name: "Home", + Order: 0, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + }, + } + mockService := &mockPageService{pages: mockPages} + handler := &DashboardHandler{ - templates: mockTemplate, + pageService: mockService, + templates: mockTemplate, } // Create request with user ID in context @@ -50,8 +120,11 @@ func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) { func TestHandleDashboard_WithoutUserID(t *testing.T) { // Setup mockTemplate := createMockDashboardTemplate() + mockService := &mockPageService{} + handler := &DashboardHandler{ - templates: mockTemplate, + pageService: mockService, + templates: mockTemplate, } // Create request without user ID in context diff --git a/internal/handlers/page_handler.go b/internal/handlers/page_handler.go new file mode 100644 index 0000000..94489a7 --- /dev/null +++ b/internal/handlers/page_handler.go @@ -0,0 +1,275 @@ +package handlers + +import ( + "encoding/json" + "html/template" + "log" + "net/http" + "path/filepath" + + "custom-start-page/internal/middleware" + "custom-start-page/internal/services" +) + +// PageHandler handles page-related HTTP requests +type PageHandler struct { + pageService services.PageServiceInterface + templates *template.Template +} + +// NewPageHandler creates a new page handler +func NewPageHandler(pageService services.PageServiceInterface) *PageHandler { + // Parse templates + templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html"))) + template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html"))) + template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html"))) + + return &PageHandler{ + pageService: pageService, + templates: templates, + } +} + +// HandleGetPage returns the widget grid HTML fragment for a specific page +// GET /pages/:id +func (h *PageHandler) HandleGetPage(w http.ResponseWriter, r *http.Request) { + // Get user ID from context + userID, ok := middleware.GetUserIDFromContext(r.Context()) + if !ok { + http.Error(w, "User ID not found in context", http.StatusInternalServerError) + return + } + + // Get page ID from URL path + pageID := r.PathValue("id") + if pageID == "" { + http.Error(w, "Page ID is required", http.StatusBadRequest) + return + } + + // TODO: Fetch widgets for this page + // For now, return empty widget grid + data := map[string]interface{}{ + "PageID": pageID, + "UserID": userID, + "Widgets": []interface{}{}, + } + + if err := h.templates.ExecuteTemplate(w, "widget-grid.html", data); err != nil { + log.Printf("Failed to render widget grid template: %v", err) + http.Error(w, "Internal server error", http.StatusInternalServerError) + } +} + +// HandleCreatePage creates a new page and returns updated page tabs HTML +// POST /pages +func (h *PageHandler) HandleCreatePage(w http.ResponseWriter, r *http.Request) { + // Get user ID from context + userID, ok := middleware.GetUserIDFromContext(r.Context()) + if !ok { + http.Error(w, "User ID not found in context", http.StatusInternalServerError) + return + } + + // Parse form data + if err := r.ParseForm(); err != nil { + http.Error(w, "Failed to parse form data", http.StatusBadRequest) + return + } + + pageName := r.FormValue("name") + if pageName == "" { + http.Error(w, "Page name is required", http.StatusBadRequest) + return + } + + // Validate page name length + if len(pageName) < 1 || len(pageName) > 50 { + http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest) + return + } + + // Create the page + _, err := h.pageService.CreatePage(r.Context(), userID, pageName) + if err != nil { + log.Printf("Failed to create page: %v", err) + http.Error(w, "Failed to create page", http.StatusInternalServerError) + return + } + + // Get all pages to render updated tabs + pages, err := h.pageService.GetPages(r.Context(), userID) + if err != nil { + log.Printf("Failed to get pages: %v", err) + http.Error(w, "Failed to get pages", http.StatusInternalServerError) + return + } + + // Render page tabs partial + data := map[string]interface{}{ + "Pages": pages, + } + + if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil { + log.Printf("Failed to render page tabs template: %v", err) + http.Error(w, "Internal server error", http.StatusInternalServerError) + } +} + +// HandleUpdatePage updates a page and returns updated page tab HTML +// PUT /pages/:id +func (h *PageHandler) HandleUpdatePage(w http.ResponseWriter, r *http.Request) { + // Get user ID from context + userID, ok := middleware.GetUserIDFromContext(r.Context()) + if !ok { + http.Error(w, "User ID not found in context", http.StatusInternalServerError) + return + } + + // Get page ID from URL path + pageID := r.PathValue("id") + if pageID == "" { + http.Error(w, "Page ID is required", http.StatusBadRequest) + return + } + + // Parse form data + if err := r.ParseForm(); err != nil { + http.Error(w, "Failed to parse form data", http.StatusBadRequest) + return + } + + pageName := r.FormValue("name") + if pageName == "" { + http.Error(w, "Page name is required", http.StatusBadRequest) + return + } + + // Validate page name length + if len(pageName) < 1 || len(pageName) > 50 { + http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest) + return + } + + // Update the page + page, err := h.pageService.UpdatePage(r.Context(), userID, pageID, pageName) + if err != nil { + log.Printf("Failed to update page: %v", err) + http.Error(w, "Failed to update page", http.StatusInternalServerError) + return + } + + // Render single page tab partial + data := map[string]interface{}{ + "Page": page, + } + + if err := h.templates.ExecuteTemplate(w, "page-tab.html", data); err != nil { + log.Printf("Failed to render page tab template: %v", err) + http.Error(w, "Internal server error", http.StatusInternalServerError) + } +} + +// HandleDeletePage deletes a page and returns updated page tabs HTML +// DELETE /pages/:id +func (h *PageHandler) HandleDeletePage(w http.ResponseWriter, r *http.Request) { + // Get user ID from context + userID, ok := middleware.GetUserIDFromContext(r.Context()) + if !ok { + http.Error(w, "User ID not found in context", http.StatusInternalServerError) + return + } + + // Get page ID from URL path + pageID := r.PathValue("id") + if pageID == "" { + http.Error(w, "Page ID is required", http.StatusBadRequest) + return + } + + // Delete the page + err := h.pageService.DeletePage(r.Context(), userID, pageID) + if err != nil { + if err.Error() == "cannot delete the last page" { + http.Error(w, "Cannot delete the last page. You must have at least one page.", http.StatusBadRequest) + return + } + log.Printf("Failed to delete page: %v", err) + http.Error(w, "Failed to delete page", http.StatusInternalServerError) + return + } + + // Get all pages to render updated tabs + pages, err := h.pageService.GetPages(r.Context(), userID) + if err != nil { + log.Printf("Failed to get pages: %v", err) + http.Error(w, "Failed to get pages", http.StatusInternalServerError) + return + } + + // Render page tabs partial + data := map[string]interface{}{ + "Pages": pages, + } + + if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil { + log.Printf("Failed to render page tabs template: %v", err) + http.Error(w, "Internal server error", http.StatusInternalServerError) + } +} + +// HandleReorderPages reorders pages and returns updated page tabs HTML +// POST /pages/reorder +func (h *PageHandler) HandleReorderPages(w http.ResponseWriter, r *http.Request) { + // Get user ID from context + userID, ok := middleware.GetUserIDFromContext(r.Context()) + if !ok { + http.Error(w, "User ID not found in context", http.StatusInternalServerError) + return + } + + // Parse form data + if err := r.ParseForm(); err != nil { + http.Error(w, "Failed to parse form data", http.StatusBadRequest) + return + } + + // Get page order from form + orderJSON := r.FormValue("order") + if orderJSON == "" { + http.Error(w, "Page order is required", http.StatusBadRequest) + return + } + + var pageOrder []string + if err := json.Unmarshal([]byte(orderJSON), &pageOrder); err != nil { + http.Error(w, "Invalid page order format", http.StatusBadRequest) + return + } + + // Reorder pages + err := h.pageService.ReorderPages(r.Context(), userID, pageOrder) + if err != nil { + log.Printf("Failed to reorder pages: %v", err) + http.Error(w, "Failed to reorder pages", http.StatusInternalServerError) + return + } + + // Get all pages to render updated tabs + pages, err := h.pageService.GetPages(r.Context(), userID) + if err != nil { + log.Printf("Failed to get pages: %v", err) + http.Error(w, "Failed to get pages", http.StatusInternalServerError) + return + } + + // Render page tabs partial + data := map[string]interface{}{ + "Pages": pages, + } + + if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil { + log.Printf("Failed to render page tabs template: %v", err) + http.Error(w, "Internal server error", http.StatusInternalServerError) + } +} diff --git a/internal/handlers/page_handler_test.go b/internal/handlers/page_handler_test.go new file mode 100644 index 0000000..2bd4738 --- /dev/null +++ b/internal/handlers/page_handler_test.go @@ -0,0 +1,251 @@ +package handlers + +import ( + "context" + "html/template" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" + + "custom-start-page/internal/middleware" +) + +// createMockPageTemplate creates a simple mock template for testing +func createMockPageTemplate() *template.Template { + tmpl := template.New("base") + + // Define page-tabs template + template.Must(tmpl.New("page-tabs.html").Parse(`{{define "page-tabs.html"}}{{range .Pages}}{{end}}{{end}}`)) + + // Define widget-grid template + template.Must(tmpl.New("widget-grid.html").Parse(`{{define "widget-grid.html"}}
Widgets for page {{.PageID}}
{{end}}`)) + + // Define page-tab template + template.Must(tmpl.New("page-tab.html").Parse(`{{define "page-tab.html"}}{{end}}`)) + + return tmpl +} + +// TestHandleGetPage tests retrieving a page's widget grid +func TestHandleGetPage(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Create request with user ID in context + req := httptest.NewRequest(http.MethodGet, "/pages/page-1", nil) + req.SetPathValue("id", "page-1") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + // Execute + handler.HandleGetPage(w, req) + + // Assert + if w.Code != http.StatusOK { + t.Errorf("Expected status 200, got %d", w.Code) + } + + body := w.Body.String() + if !strings.Contains(body, "page-1") { + t.Errorf("Expected response to contain page ID, got: %s", body) + } +} + +// TestHandleCreatePage tests creating a new page +func TestHandleCreatePage(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Create form data + form := url.Values{} + form.Add("name", "New Page") + + // Create request with user ID in context + req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode())) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + // Execute + handler.HandleCreatePage(w, req) + + // Assert + if w.Code != http.StatusOK { + t.Errorf("Expected status 200, got %d", w.Code) + } + + // Verify page was created + if len(mockService.pages) != 1 { + t.Errorf("Expected 1 page to be created, got %d", len(mockService.pages)) + } + + if mockService.pages[0].Name != "New Page" { + t.Errorf("Expected page name 'New Page', got '%s'", mockService.pages[0].Name) + } +} + +// TestHandleCreatePage_InvalidName tests creating a page with invalid name +func TestHandleCreatePage_InvalidName(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Test empty name + form := url.Values{} + form.Add("name", "") + + req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode())) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + handler.HandleCreatePage(w, req) + + if w.Code != http.StatusBadRequest { + t.Errorf("Expected status 400 for empty name, got %d", w.Code) + } + + // Test name too long + form = url.Values{} + form.Add("name", strings.Repeat("a", 51)) + + req = httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode())) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + ctx = context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w = httptest.NewRecorder() + + handler.HandleCreatePage(w, req) + + if w.Code != http.StatusBadRequest { + t.Errorf("Expected status 400 for name too long, got %d", w.Code) + } +} + +// TestHandleUpdatePage tests updating a page +func TestHandleUpdatePage(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + // Create initial page + _, _ = mockService.CreatePage(context.Background(), "test-user-123", "Old Name") + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Create form data + form := url.Values{} + form.Add("name", "Updated Name") + + // Create request with user ID in context + req := httptest.NewRequest(http.MethodPut, "/pages/new-page-id", strings.NewReader(form.Encode())) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + req.SetPathValue("id", "new-page-id") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + // Execute + handler.HandleUpdatePage(w, req) + + // Assert + if w.Code != http.StatusOK { + t.Errorf("Expected status 200, got %d", w.Code) + } + + // Verify page was updated + if mockService.pages[0].Name != "Updated Name" { + t.Errorf("Expected page name 'Updated Name', got '%s'", mockService.pages[0].Name) + } +} + +// TestHandleDeletePage tests deleting a page +func TestHandleDeletePage(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + // Create two pages + _, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1") + _, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2") + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Create request with user ID in context + req := httptest.NewRequest(http.MethodDelete, "/pages/page-1", nil) + req.SetPathValue("id", "page-1") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + // Execute + handler.HandleDeletePage(w, req) + + // Assert + if w.Code != http.StatusOK { + t.Errorf("Expected status 200, got %d", w.Code) + } +} + +// TestHandleReorderPages tests reordering pages +func TestHandleReorderPages(t *testing.T) { + // Setup + mockTemplate := createMockPageTemplate() + mockService := &mockPageService{} + + // Create pages + _, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1") + _, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2") + + handler := &PageHandler{ + pageService: mockService, + templates: mockTemplate, + } + + // Create form data with JSON array + form := url.Values{} + form.Add("order", `["page-2", "page-1"]`) + + // Create request with user ID in context + req := httptest.NewRequest(http.MethodPost, "/pages/reorder", strings.NewReader(form.Encode())) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123") + req = req.WithContext(ctx) + w := httptest.NewRecorder() + + // Execute + handler.HandleReorderPages(w, req) + + // Assert + if w.Code != http.StatusOK { + t.Errorf("Expected status 200, got %d", w.Code) + } +} diff --git a/internal/services/interfaces.go b/internal/services/interfaces.go new file mode 100644 index 0000000..d236a4c --- /dev/null +++ b/internal/services/interfaces.go @@ -0,0 +1,17 @@ +package services + +import ( + "context" + + "custom-start-page/internal/models" +) + +// PageServiceInterface defines the interface for page operations +type PageServiceInterface interface { + GetPages(ctx context.Context, userID string) ([]*models.Page, error) + CreatePage(ctx context.Context, userID, name string) (*models.Page, error) + CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) + UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) + DeletePage(ctx context.Context, userID, pageID string) error + ReorderPages(ctx context.Context, userID string, pageOrder []string) error +} diff --git a/internal/services/page_service.go b/internal/services/page_service.go new file mode 100644 index 0000000..d4eb122 --- /dev/null +++ b/internal/services/page_service.go @@ -0,0 +1,275 @@ +package services + +import ( + "context" + "fmt" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue" + "github.com/aws/aws-sdk-go-v2/service/dynamodb" + "github.com/aws/aws-sdk-go-v2/service/dynamodb/types" + "github.com/google/uuid" + + "custom-start-page/internal/models" + "custom-start-page/internal/storage" +) + +// PageService handles all page-related business logic +type PageService struct { + db *storage.DynamoDBClient +} + +// NewPageService creates a new PageService instance +func NewPageService(db *storage.DynamoDBClient) *PageService { + return &PageService{ + db: db, + } +} + +// GetPages retrieves all pages for a user in display order +func (s *PageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) { + input := &dynamodb.QueryInput{ + TableName: aws.String("Pages"), + KeyConditionExpression: aws.String("user_id = :user_id"), + ExpressionAttributeValues: map[string]types.AttributeValue{ + ":user_id": &types.AttributeValueMemberS{Value: userID}, + }, + } + + output, err := s.db.Query(ctx, input) + if err != nil { + return nil, fmt.Errorf("failed to query pages: %w", err) + } + + var pages []*models.Page + err = attributevalue.UnmarshalListOfMaps(output.Items, &pages) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal pages: %w", err) + } + + // Sort by order field + sortPagesByOrder(pages) + + return pages, nil +} + +// CreatePage creates a new page for a user +func (s *PageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) { + // Get existing pages to determine the next order + existingPages, err := s.GetPages(ctx, userID) + if err != nil { + return nil, fmt.Errorf("failed to get existing pages: %w", err) + } + + nextOrder := len(existingPages) + + page := &models.Page{ + ID: uuid.New().String(), + UserID: userID, + Name: name, + Order: nextOrder, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + + item, err := attributevalue.MarshalMap(page) + if err != nil { + return nil, fmt.Errorf("failed to marshal page: %w", err) + } + + input := &dynamodb.PutItemInput{ + TableName: aws.String("Pages"), + Item: item, + } + + err = s.db.PutItem(ctx, input) + if err != nil { + return nil, fmt.Errorf("failed to create page: %w", err) + } + + return page, nil +} + +// CreateDefaultPage creates the default "Home" page for new users +func (s *PageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) { + return s.CreatePage(ctx, userID, "Home") +} + +// UpdatePage updates a page's name or order +func (s *PageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) { + now := time.Now() + + input := &dynamodb.UpdateItemInput{ + TableName: aws.String("Pages"), + Key: map[string]types.AttributeValue{ + "user_id": &types.AttributeValueMemberS{Value: userID}, + "page_id": &types.AttributeValueMemberS{Value: pageID}, + }, + UpdateExpression: aws.String("SET #name = :name, updated_at = :updated_at"), + ExpressionAttributeNames: map[string]string{ + "#name": "name", + }, + ExpressionAttributeValues: map[string]types.AttributeValue{ + ":name": &types.AttributeValueMemberS{Value: name}, + ":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)}, + }, + ReturnValues: types.ReturnValueAllNew, + } + + output, err := s.db.UpdateItem(ctx, input) + if err != nil { + return nil, fmt.Errorf("failed to update page: %w", err) + } + + var page models.Page + err = attributevalue.UnmarshalMap(output.Attributes, &page) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal updated page: %w", err) + } + + return &page, nil +} + +// DeletePage deletes a page and all associated widgets +func (s *PageService) DeletePage(ctx context.Context, userID, pageID string) error { + // Check if this is the last page + pages, err := s.GetPages(ctx, userID) + if err != nil { + return fmt.Errorf("failed to get pages: %w", err) + } + + if len(pages) <= 1 { + return fmt.Errorf("cannot delete the last page") + } + + // Get all widgets for this page + widgetsInput := &dynamodb.QueryInput{ + TableName: aws.String("Widgets"), + KeyConditionExpression: aws.String("page_id = :page_id"), + ExpressionAttributeValues: map[string]types.AttributeValue{ + ":page_id": &types.AttributeValueMemberS{Value: pageID}, + }, + } + + widgetsOutput, err := s.db.Query(ctx, widgetsInput) + if err != nil { + return fmt.Errorf("failed to query widgets: %w", err) + } + + // Delete all widgets in batches + if len(widgetsOutput.Items) > 0 { + var writeRequests []types.WriteRequest + for _, item := range widgetsOutput.Items { + writeRequests = append(writeRequests, types.WriteRequest{ + DeleteRequest: &types.DeleteRequest{ + Key: map[string]types.AttributeValue{ + "page_id": item["page_id"], + "widget_id": item["widget_id"], + }, + }, + }) + } + + // Process in batches of 25 (DynamoDB limit) + for i := 0; i < len(writeRequests); i += 25 { + end := i + 25 + if end > len(writeRequests) { + end = len(writeRequests) + } + + batchInput := &dynamodb.BatchWriteItemInput{ + RequestItems: map[string][]types.WriteRequest{ + "Widgets": writeRequests[i:end], + }, + } + + err = s.db.BatchWriteItems(ctx, batchInput) + if err != nil { + return fmt.Errorf("failed to delete widgets: %w", err) + } + } + } + + // Delete the page + deleteInput := &dynamodb.DeleteItemInput{ + TableName: aws.String("Pages"), + Key: map[string]types.AttributeValue{ + "user_id": &types.AttributeValueMemberS{Value: userID}, + "page_id": &types.AttributeValueMemberS{Value: pageID}, + }, + } + + err = s.db.DeleteItem(ctx, deleteInput) + if err != nil { + return fmt.Errorf("failed to delete page: %w", err) + } + + return nil +} + +// ReorderPages updates the display order of pages +func (s *PageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error { + // Validate that all pages exist and belong to the user + existingPages, err := s.GetPages(ctx, userID) + if err != nil { + return fmt.Errorf("failed to get existing pages: %w", err) + } + + // Create a map for quick lookup + pageMap := make(map[string]*models.Page) + for _, page := range existingPages { + pageMap[page.ID] = page + } + + // Validate all page IDs in the order list + if len(pageOrder) != len(existingPages) { + return fmt.Errorf("page order list length mismatch: expected %d, got %d", len(existingPages), len(pageOrder)) + } + + for _, pageID := range pageOrder { + if _, exists := pageMap[pageID]; !exists { + return fmt.Errorf("page %s not found or does not belong to user", pageID) + } + } + + // Update each page's order + now := time.Now() + for i, pageID := range pageOrder { + input := &dynamodb.UpdateItemInput{ + TableName: aws.String("Pages"), + Key: map[string]types.AttributeValue{ + "user_id": &types.AttributeValueMemberS{Value: userID}, + "page_id": &types.AttributeValueMemberS{Value: pageID}, + }, + UpdateExpression: aws.String("SET #order = :order, updated_at = :updated_at"), + ExpressionAttributeNames: map[string]string{ + "#order": "order", + }, + ExpressionAttributeValues: map[string]types.AttributeValue{ + ":order": &types.AttributeValueMemberN{Value: fmt.Sprintf("%d", i)}, + ":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)}, + }, + } + + _, err = s.db.UpdateItem(ctx, input) + if err != nil { + return fmt.Errorf("failed to update page order for page %s: %w", pageID, err) + } + } + + return nil +} + +// sortPagesByOrder sorts pages by their order field (in-place) +func sortPagesByOrder(pages []*models.Page) { + // Simple bubble sort since we expect small number of pages + n := len(pages) + for i := 0; i < n-1; i++ { + for j := 0; j < n-i-1; j++ { + if pages[j].Order > pages[j+1].Order { + pages[j], pages[j+1] = pages[j+1], pages[j] + } + } + } +} diff --git a/internal/services/page_service_test.go b/internal/services/page_service_test.go new file mode 100644 index 0000000..3fb8170 --- /dev/null +++ b/internal/services/page_service_test.go @@ -0,0 +1,350 @@ +package services + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue" + "github.com/aws/aws-sdk-go-v2/service/dynamodb" + "github.com/aws/aws-sdk-go-v2/service/dynamodb/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "custom-start-page/internal/models" + "custom-start-page/internal/storage" +) + +func setupPageServiceTest(t *testing.T) (*PageService, context.Context, func()) { + ctx := context.Background() + + // Create DynamoDB client + db, err := storage.NewDynamoDBClient(ctx, "http://localhost:8000") + require.NoError(t, err, "Failed to create DynamoDB client") + + // Create tables + err = db.CreatePagesTable(ctx) + require.NoError(t, err, "Failed to create Pages table") + + err = db.CreateWidgetsTable(ctx) + require.NoError(t, err, "Failed to create Widgets table") + + service := NewPageService(db) + + cleanup := func() { + // Clean up test data + client := db.GetClient() + + // Delete Pages table + _, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{ + TableName: aws.String("Pages"), + }) + + // Delete Widgets table + _, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{ + TableName: aws.String("Widgets"), + }) + } + + return service, ctx, cleanup +} + +func TestCreateDefaultPage(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-1" + + page, err := service.CreateDefaultPage(ctx, userID) + require.NoError(t, err) + assert.NotEmpty(t, page.ID) + assert.Equal(t, userID, page.UserID) + assert.Equal(t, "Home", page.Name) + assert.Equal(t, 0, page.Order) + assert.False(t, page.CreatedAt.IsZero()) + assert.False(t, page.UpdatedAt.IsZero()) +} + +func TestGetPages(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-2" + + // Create multiple pages + page1, err := service.CreatePage(ctx, userID, "Home") + require.NoError(t, err) + + page2, err := service.CreatePage(ctx, userID, "Work") + require.NoError(t, err) + + page3, err := service.CreatePage(ctx, userID, "Personal") + require.NoError(t, err) + + // Get all pages + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + assert.Len(t, pages, 3) + + // Verify pages are sorted by order + assert.Equal(t, page1.ID, pages[0].ID) + assert.Equal(t, page2.ID, pages[1].ID) + assert.Equal(t, page3.ID, pages[2].ID) + + assert.Equal(t, 0, pages[0].Order) + assert.Equal(t, 1, pages[1].Order) + assert.Equal(t, 2, pages[2].Order) +} + +func TestGetPagesEmptyResult(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-nonexistent" + + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + assert.Empty(t, pages) +} + +func TestCreatePage(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-3" + + page, err := service.CreatePage(ctx, userID, "Test Page") + require.NoError(t, err) + assert.NotEmpty(t, page.ID) + assert.Equal(t, userID, page.UserID) + assert.Equal(t, "Test Page", page.Name) + assert.Equal(t, 0, page.Order) + + // Create another page + page2, err := service.CreatePage(ctx, userID, "Second Page") + require.NoError(t, err) + assert.Equal(t, 1, page2.Order) +} + +func TestUpdatePage(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-4" + + // Create a page + page, err := service.CreatePage(ctx, userID, "Original Name") + require.NoError(t, err) + + // Update the page name + updatedPage, err := service.UpdatePage(ctx, userID, page.ID, "Updated Name") + require.NoError(t, err) + assert.Equal(t, page.ID, updatedPage.ID) + assert.Equal(t, "Updated Name", updatedPage.Name) + assert.True(t, updatedPage.UpdatedAt.After(page.UpdatedAt) || updatedPage.UpdatedAt.Equal(page.UpdatedAt)) +} + +func TestDeletePage(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-5" + + // Create multiple pages + page1, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + page2, err := service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + // Delete page2 + err = service.DeletePage(ctx, userID, page2.ID) + require.NoError(t, err) + + // Verify only page1 remains + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + assert.Len(t, pages, 1) + assert.Equal(t, page1.ID, pages[0].ID) +} + +func TestDeleteLastPagePrevention(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-6" + + // Create a single page + page, err := service.CreatePage(ctx, userID, "Only Page") + require.NoError(t, err) + + // Attempt to delete the last page + err = service.DeletePage(ctx, userID, page.ID) + assert.Error(t, err) + assert.Contains(t, err.Error(), "cannot delete the last page") + + // Verify page still exists + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + assert.Len(t, pages, 1) +} + +func TestDeletePageWithWidgets(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-7" + + // Create two pages + _, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + page2, err := service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + // Add widgets to page2 + db := service.db + for i := 0; i < 3; i++ { + widget := &models.Widget{ + ID: fmt.Sprintf("widget-%d", i), + PageID: page2.ID, + UserID: userID, + Type: models.WidgetTypeBookmark, + Position: models.Position{X: 0, Y: i}, + Size: models.Size{Width: 1, Height: 1}, + Config: make(map[string]interface{}), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + + item, err := attributevalue.MarshalMap(widget) + require.NoError(t, err) + + err = db.PutItem(ctx, &dynamodb.PutItemInput{ + TableName: aws.String("Widgets"), + Item: item, + }) + require.NoError(t, err) + } + + // Delete page2 (should cascade delete widgets) + err = service.DeletePage(ctx, userID, page2.ID) + require.NoError(t, err) + + // Verify widgets are deleted + widgetsOutput, err := db.Query(ctx, &dynamodb.QueryInput{ + TableName: aws.String("Widgets"), + KeyConditionExpression: aws.String("page_id = :page_id"), + ExpressionAttributeValues: map[string]types.AttributeValue{ + ":page_id": &types.AttributeValueMemberS{Value: page2.ID}, + }, + }) + require.NoError(t, err) + assert.Empty(t, widgetsOutput.Items) +} + +func TestReorderPages(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-8" + + // Create three pages + page1, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + page2, err := service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + page3, err := service.CreatePage(ctx, userID, "Page 3") + require.NoError(t, err) + + // Reorder: page3, page1, page2 + newOrder := []string{page3.ID, page1.ID, page2.ID} + err = service.ReorderPages(ctx, userID, newOrder) + require.NoError(t, err) + + // Verify new order + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + assert.Len(t, pages, 3) + + assert.Equal(t, page3.ID, pages[0].ID) + assert.Equal(t, 0, pages[0].Order) + + assert.Equal(t, page1.ID, pages[1].ID) + assert.Equal(t, 1, pages[1].Order) + + assert.Equal(t, page2.ID, pages[2].ID) + assert.Equal(t, 2, pages[2].Order) +} + +func TestReorderPagesInvalidLength(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-9" + + // Create two pages + page1, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + _, err = service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + // Attempt to reorder with wrong number of pages + err = service.ReorderPages(ctx, userID, []string{page1.ID}) + assert.Error(t, err) + assert.Contains(t, err.Error(), "page order list length mismatch") +} + +func TestReorderPagesInvalidPageID(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-10" + + // Create two pages + page1, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + _, err = service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + // Attempt to reorder with invalid page ID + err = service.ReorderPages(ctx, userID, []string{page1.ID, "invalid-page-id"}) + assert.Error(t, err) + assert.Contains(t, err.Error(), "not found or does not belong to user") +} + +func TestReorderPagesPersistence(t *testing.T) { + service, ctx, cleanup := setupPageServiceTest(t) + defer cleanup() + + userID := "test-user-11" + + // Create three pages + page1, err := service.CreatePage(ctx, userID, "Page 1") + require.NoError(t, err) + + page2, err := service.CreatePage(ctx, userID, "Page 2") + require.NoError(t, err) + + page3, err := service.CreatePage(ctx, userID, "Page 3") + require.NoError(t, err) + + // Reorder + newOrder := []string{page2.ID, page3.ID, page1.ID} + err = service.ReorderPages(ctx, userID, newOrder) + require.NoError(t, err) + + // Retrieve pages again to verify persistence + pages, err := service.GetPages(ctx, userID) + require.NoError(t, err) + + assert.Equal(t, page2.ID, pages[0].ID) + assert.Equal(t, page3.ID, pages[1].ID) + assert.Equal(t, page1.ID, pages[2].ID) +} diff --git a/internal/services/page_service_unit_test.go b/internal/services/page_service_unit_test.go new file mode 100644 index 0000000..94c09f3 --- /dev/null +++ b/internal/services/page_service_unit_test.go @@ -0,0 +1,73 @@ +package services + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "custom-start-page/internal/models" +) + +// TestSortPagesByOrder tests the sorting function without requiring DynamoDB +func TestSortPagesByOrder(t *testing.T) { + pages := []*models.Page{ + {ID: "page-3", Order: 2}, + {ID: "page-1", Order: 0}, + {ID: "page-2", Order: 1}, + } + + sortPagesByOrder(pages) + + assert.Equal(t, "page-1", pages[0].ID) + assert.Equal(t, "page-2", pages[1].ID) + assert.Equal(t, "page-3", pages[2].ID) +} + +// TestSortPagesByOrderAlreadySorted tests sorting already sorted pages +func TestSortPagesByOrderAlreadySorted(t *testing.T) { + pages := []*models.Page{ + {ID: "page-1", Order: 0}, + {ID: "page-2", Order: 1}, + {ID: "page-3", Order: 2}, + } + + sortPagesByOrder(pages) + + assert.Equal(t, "page-1", pages[0].ID) + assert.Equal(t, "page-2", pages[1].ID) + assert.Equal(t, "page-3", pages[2].ID) +} + +// TestSortPagesByOrderReversed tests sorting reversed pages +func TestSortPagesByOrderReversed(t *testing.T) { + pages := []*models.Page{ + {ID: "page-3", Order: 2}, + {ID: "page-2", Order: 1}, + {ID: "page-1", Order: 0}, + } + + sortPagesByOrder(pages) + + assert.Equal(t, "page-1", pages[0].ID) + assert.Equal(t, "page-2", pages[1].ID) + assert.Equal(t, "page-3", pages[2].ID) +} + +// TestSortPagesByOrderEmpty tests sorting empty slice +func TestSortPagesByOrderEmpty(t *testing.T) { + pages := []*models.Page{} + sortPagesByOrder(pages) + assert.Empty(t, pages) +} + +// TestSortPagesByOrderSingle tests sorting single page +func TestSortPagesByOrderSingle(t *testing.T) { + pages := []*models.Page{ + {ID: "page-1", Order: 0}, + } + + sortPagesByOrder(pages) + + assert.Len(t, pages, 1) + assert.Equal(t, "page-1", pages[0].ID) +} diff --git a/templates/dashboard.html b/templates/dashboard.html index fe2cb83..db67dab 100644 --- a/templates/dashboard.html +++ b/templates/dashboard.html @@ -48,19 +48,7 @@
- {{range .Pages}} - - {{end}} - + {{template "page-tabs.html" .}}
diff --git a/templates/partials/page-tab.html b/templates/partials/page-tab.html new file mode 100644 index 0000000..be03f81 --- /dev/null +++ b/templates/partials/page-tab.html @@ -0,0 +1,10 @@ +{{define "page-tab.html"}} + +{{end}} diff --git a/templates/partials/page-tabs.html b/templates/partials/page-tabs.html new file mode 100644 index 0000000..afe8fb9 --- /dev/null +++ b/templates/partials/page-tabs.html @@ -0,0 +1,21 @@ +{{define "page-tabs.html"}} +{{range .Pages}} + +{{end}} + +{{end}} diff --git a/templates/partials/widget-grid.html b/templates/partials/widget-grid.html new file mode 100644 index 0000000..28e0545 --- /dev/null +++ b/templates/partials/widget-grid.html @@ -0,0 +1,34 @@ +{{define "widget-grid.html"}} +{{if .Widgets}} + {{range .Widgets}} +
+
+

+ {{if .Title}}{{.Title}}{{else}}{{.Type}} Widget{{end}} +

+ +
+
+ +

{{.Type}} widget content

+
+
+ {{end}} +{{else}} +
+ + + +

No widgets yet

+

Click the + button to add your first widget

+
+{{end}} +{{end}}