254 lines
7.0 KiB
Go
254 lines
7.0 KiB
Go
package main
|
|
|
|
import (
|
|
"bookhoard/internal/handlers"
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"bookhoard/internal/config"
|
|
"bookhoard/internal/database"
|
|
"bookhoard/internal/middleware"
|
|
"bookhoard/internal/router"
|
|
"bookhoard/internal/services"
|
|
"bookhoard/internal/sync"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestKoboInitialization(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping integration test in short mode")
|
|
}
|
|
|
|
ts, db, _ := setupTestServer(t)
|
|
defer closeTestServer(t, ts, db)
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
_ = getTestUserID(t, db)
|
|
_ = createTestMediaItemID(t, ts, token)
|
|
|
|
log.Printf("[DEBUG] Kobo test setup: creating device and media")
|
|
|
|
t.Run("successful initialization", func(t *testing.T) {
|
|
// Create Kobo device using TestDeviceSetup for proper authentication
|
|
deviceSetup := setupTestDevice(t, ts, db)
|
|
koboDevice := deviceSetup.CreateDevice(t, "Test Kobo", "kobo", "kobo-clara-test")
|
|
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/sync/kobo/v1/initialization", nil)
|
|
req.Header.Set("Authorization", "Bearer "+koboDevice.AuthToken)
|
|
req.Header.Set("x-kobo-device", fmt.Sprintf(`{"DeviceId":"%s","Model":"Kobo Clara","SerialNumber":"%s"}`,
|
|
koboDevice.ID.String(), koboDevice.Identifier))
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
})
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
func TestKoboLibrarySync(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping integration test in short mode")
|
|
}
|
|
|
|
ts, db, _ := setupTestServer(t)
|
|
defer closeTestServer(t, ts, db)
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
_ = createTestMediaItemID(t, ts, token)
|
|
|
|
t.Run("successful library sync", func(t *testing.T) {
|
|
req, _ := http.NewRequest("GET", ts.URL+"/api/sync/kobo/test-token/v1/initialization", 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)
|
|
})
|
|
}
|
|
|
|
func TestKoboMarkupSync(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping integration test in short mode")
|
|
}
|
|
|
|
ts, db, _ := setupTestServer(t)
|
|
defer closeTestServer(t, ts, db)
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
mediaItemID := createTestMediaItemID(t, ts, token)
|
|
|
|
t.Run("successful markup sync with annotations and bookmarks", func(t *testing.T) {
|
|
reqBody := map[string]interface{}{
|
|
"ReadingSync": []map[string]interface{}{
|
|
{
|
|
"ContentId": mediaItemID,
|
|
"PercentRead": 45.6,
|
|
"EntitlementId": "ent-123",
|
|
"RemainingTimeMinutes": 120,
|
|
"LastModified": "2026-01-30T20:00:00Z",
|
|
},
|
|
},
|
|
"BookmarkSync": []map[string]interface{}{
|
|
{
|
|
"BookmarkId": "bookmark-1",
|
|
"ContentId": mediaItemID,
|
|
"BookmarkText": "This is highlighted text",
|
|
"BookmarkType": "annotation",
|
|
"BookmarkTitle": "Chapter 3",
|
|
},
|
|
{
|
|
"BookmarkId": "bookmark-2",
|
|
"ContentId": mediaItemID,
|
|
"BookmarkText": "This is my note abouts book",
|
|
"BookmarkType": "bookmark",
|
|
},
|
|
},
|
|
}
|
|
|
|
body, _ := json.Marshal(reqBody)
|
|
req, _ := http.NewRequest("POST", ts.URL+"/api/sync/kobo/markup", bytes.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("x-kobo-device", `{"DeviceId":"kobo-clara-test","Model":"Kobo Clara","SerialNumber":"N123456789"}`)
|
|
|
|
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, "Status")
|
|
})
|
|
}
|
|
|
|
func TestKoboBookmarkSync(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping integration test in short mode")
|
|
}
|
|
|
|
ts, db, _ := setupTestServer(t)
|
|
defer closeTestServer(t, ts, db)
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
mediaItemID := createTestMediaItemID(t, ts, token)
|
|
|
|
t.Run("successful bookmark sync", func(t *testing.T) {
|
|
reqBody := map[string]interface{}{
|
|
"BookmarkSync": []map[string]interface{}{
|
|
{
|
|
"BookmarkId": "bookmark-3",
|
|
"ContentId": mediaItemID,
|
|
"BookmarkText": "Important note abouts book",
|
|
"BookmarkType": "bookmark",
|
|
"DateCreated": "2026-01-30T19:55:00Z",
|
|
},
|
|
},
|
|
}
|
|
|
|
body, _ := json.Marshal(reqBody)
|
|
req, _ := http.NewRequest("POST", ts.URL+"/api/sync/kobo/bookmark", bytes.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("x-kobo-device", `{"DeviceId":"kobo-clara-test","Model":"Kobo Clara","SerialNumber":"N123456789"}`)
|
|
|
|
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, "Status")
|
|
})
|
|
}
|
|
|
|
func TestKoboAnalyticsGettests(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping integration test in short mode")
|
|
}
|
|
|
|
ts, db, _ := setupTestServer(t)
|
|
defer closeTestServer(t, ts, db)
|
|
|
|
token := loginTestUser(t, ts, db)
|
|
mediaItemID := createTestMediaItemID(t, ts, token)
|
|
|
|
t.Run("successful analytics tests", func(t *testing.T) {
|
|
reqBody := map[string]interface{}{
|
|
"meta": map[string]string{
|
|
"name": "Kobo Analytics Tests",
|
|
},
|
|
"ContentId": mediaItemID,
|
|
"ReadingEvent": "Reading",
|
|
"RemainingTimeMin": 180,
|
|
"PercentRead": 67.8,
|
|
}
|
|
|
|
body, _ := json.Marshal(reqBody)
|
|
req, _ := http.NewRequest("POST", ts.URL+"/api/sync/kobo/v1/analytics/gettests", bytes.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("x-kobo-device", `{"DeviceId":"kobo-clara-test","Model":"Kobo Clara","SerialNumber":"N123456789"}`)
|
|
|
|
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, "Status")
|
|
})
|
|
}
|
|
|
|
func TestKoboDeviceHeaderParsing(t *testing.T) {
|
|
t.Run("valid device header", func(t *testing.T) {
|
|
reqBody := map[string]interface{}{
|
|
"DeviceId": "kobo-clara-test",
|
|
"Model": "Kobo Clara",
|
|
"SerialNumber": "N123456789",
|
|
"Firmware": "4.38.23555",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(reqBody)
|
|
|
|
var device handlers.KoboDeviceInfo
|
|
err := json.Unmarshal(jsonData, &device)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "kobo-clara-test", device.DeviceID)
|
|
assert.Equal(t, "Kobo Clara", device.Model)
|
|
assert.Equal(t, "N123456789", device.SerialNumber)
|
|
assert.Equal(t, "4.38.23555", device.Firmware)
|
|
})
|
|
}
|
|
|
|
func closeTestServer(t *testing.T, ts interface{}, db interface{}) {
|
|
if ts, ok := ts.(*httptest.Server); ok {
|
|
ts.Close()
|
|
}
|
|
}
|