471 lines
14 KiB
Go
471 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestAnalyticsReadingStats tests the reading statistics endpoint
|
|
func TestAnalyticsReadingStats(t *testing.T) {
|
|
t.Run("GetReadingStats_WithoutAuth", func(t *testing.T) {
|
|
ts, _, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats", nil)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetReadingStats_WithAuth_DefaultDates", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
assert.Contains(t, result, "total_books_read")
|
|
assert.Contains(t, result, "total_pages_read")
|
|
assert.Contains(t, result, "total_reading_time_minutes")
|
|
assert.Contains(t, result, "average_session_time_minutes")
|
|
assert.Contains(t, result, "completion_rate")
|
|
assert.Contains(t, result, "daily_reading_minutes")
|
|
})
|
|
|
|
t.Run("GetReadingStats_WithCustomDateRange", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
startDate := time.Now().AddDate(0, -2, 0).Format("2006-01-02")
|
|
endDate := time.Now().Format("2006-01-02")
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats?start_date="+startDate+"&end_date="+endDate, nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetReadingStats_InvalidStartDate", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats?start_date=invalid-date", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetReadingStats_InvalidEndDate", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats?end_date=not-a-date", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetReadingStats_EmptyHistory", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
// Should return zero values for empty history
|
|
assert.Equal(t, 0.0, result["total_books_read"])
|
|
assert.Equal(t, 0.0, result["total_pages_read"])
|
|
})
|
|
}
|
|
|
|
// TestAnalyticsDeviceUsage tests the device usage endpoint
|
|
func TestAnalyticsDeviceUsage(t *testing.T) {
|
|
t.Run("GetDeviceUsage_WithoutAuth", func(t *testing.T) {
|
|
ts, _, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/device-usage", nil)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetDeviceUsage_WithAuth_NoDevices", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/device-usage", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
devices, ok := result["devices"].([]interface{})
|
|
assert.True(t, ok)
|
|
assert.Equal(t, 0, len(devices))
|
|
})
|
|
|
|
t.Run("GetDeviceUsage_WithAuth_WithDevices", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
// First create a device
|
|
deviceReq := map[string]interface{}{
|
|
"device_name": "Test Kobo",
|
|
"device_type": "kobo",
|
|
}
|
|
deviceBody, _ := json.Marshal(deviceReq)
|
|
|
|
deviceReqHTTP, _ := http.NewRequest("POST", ts.URL+"/api/devices/register", bytes.NewBuffer(deviceBody))
|
|
deviceReqHTTP.Header.Set("Content-Type", "application/json")
|
|
deviceReqHTTP.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(deviceReqHTTP)
|
|
require.NoError(t, err)
|
|
resp.Body.Close()
|
|
|
|
// Now get device usage
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/device-usage", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
resp, err = client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
devices, ok := result["devices"].([]interface{})
|
|
assert.True(t, ok)
|
|
// May be 0 if device has no usage data yet
|
|
assert.NotNil(t, devices)
|
|
})
|
|
|
|
t.Run("GetDeviceUsage_ResponseStructure", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/device-usage", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
assert.Contains(t, result, "devices")
|
|
|
|
// Check device structure if any devices exist
|
|
if devices, ok := result["devices"].([]interface{}); ok && len(devices) > 0 {
|
|
firstDevice := devices[0].(map[string]interface{})
|
|
assert.Contains(t, firstDevice, "device_id")
|
|
assert.Contains(t, firstDevice, "device_name")
|
|
assert.Contains(t, firstDevice, "device_type")
|
|
assert.Contains(t, firstDevice, "sync_count")
|
|
assert.Contains(t, firstDevice, "last_sync")
|
|
assert.Contains(t, firstDevice, "total_time_seconds")
|
|
assert.Contains(t, firstDevice, "total_time_minutes")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestAnalyticsPopularBooks tests the popular books endpoint
|
|
func TestAnalyticsPopularBooks(t *testing.T) {
|
|
t.Run("GetPopularBooks_WithoutAuth", func(t *testing.T) {
|
|
ts, _, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books", nil)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("GetPopularBooks_WithAuth_DefaultLimit", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
assert.Contains(t, result, "books")
|
|
books := result["books"].([]interface{})
|
|
assert.NotNil(t, books)
|
|
// Default limit is 10, but may be fewer if no reading history
|
|
assert.True(t, len(books) <= 10)
|
|
})
|
|
|
|
t.Run("GetPopularBooks_WithCustomLimit", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books?limit=5", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
books := result["books"].([]interface{})
|
|
assert.True(t, len(books) <= 5)
|
|
})
|
|
|
|
t.Run("GetPopularBooks_InvalidLimit", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books?limit=invalid", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Should default to 10 on invalid limit
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
books := result["books"].([]interface{})
|
|
assert.True(t, len(books) <= 10)
|
|
})
|
|
|
|
t.Run("GetPopularBooks_ResponseStructure", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
// First create a book and some reading history
|
|
bookID := createTestEbookID(t, ts, token)
|
|
|
|
// Create reading history for the book
|
|
historyReq := map[string]interface{}{
|
|
"media_item_id": bookID,
|
|
"progress_percentage": 50.0,
|
|
"pages_read": 100,
|
|
"time_spent_seconds": 1800,
|
|
}
|
|
historyBody, _ := json.Marshal(historyReq)
|
|
|
|
historyHTTP, _ := http.NewRequest("POST", ts.URL+"/api/media-items/"+bookID+"/progress", bytes.NewBuffer(historyBody))
|
|
historyHTTP.Header.Set("Content-Type", "application/json")
|
|
historyHTTP.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(historyHTTP)
|
|
require.NoError(t, err)
|
|
resp.Body.Close()
|
|
|
|
// Now get popular books
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
resp, err = client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
books := result["books"].([]interface{})
|
|
|
|
// Check book structure if any books exist
|
|
if len(books) > 0 {
|
|
firstBook := books[0].(map[string]interface{})
|
|
assert.Contains(t, firstBook, "media_item_id")
|
|
assert.Contains(t, firstBook, "title")
|
|
assert.Contains(t, firstBook, "author")
|
|
assert.Contains(t, firstBook, "read_count")
|
|
assert.Contains(t, firstBook, "avg_completion")
|
|
assert.Contains(t, firstBook, "last_read")
|
|
}
|
|
})
|
|
|
|
t.Run("GetPopularBooks_NoReadingHistory", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
books := result["books"].([]interface{})
|
|
// Should return empty array if no reading history
|
|
assert.Equal(t, 0, len(books))
|
|
})
|
|
}
|
|
|
|
// TestAnalyticsEdgeCases tests edge cases for analytics endpoints
|
|
func TestAnalyticsEdgeCases(t *testing.T) {
|
|
t.Run("ReadingStats_FutureDateRange", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
startDate := time.Now().AddDate(0, 0, 7).Format("2006-01-02")
|
|
endDate := time.Now().AddDate(0, 0, 14).Format("2006-01-02")
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/reading-stats?start_date="+startDate+"&end_date="+endDate, nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Should succeed but return empty stats
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
assert.Equal(t, 0.0, result["total_books_read"])
|
|
})
|
|
|
|
t.Run("PopularBooks_LimitZero", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books?limit=0", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Should handle limit=0 gracefully
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
books := result["books"].([]interface{})
|
|
assert.Equal(t, 0, len(books))
|
|
})
|
|
|
|
t.Run("PopularBooks_VeryLargeLimit", func(t *testing.T) {
|
|
ts, db, _, _ := setupTestServer(t)
|
|
defer ts.Close()
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/analytics/popular-books?limit=999999", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Should handle large limit
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
})
|
|
}
|