mirror of
https://github.com/dnote/dnote
synced 2026-03-14 22:45:50 +01:00
Handle server switch
This commit is contained in:
Sung
parent
e0f68fc8d8
commit
4d1cfcc10d
10 changed files with 914 additions and 53 deletions
|
|
@ -22,6 +22,8 @@ import (
|
|||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var apiEndpointFlag string
|
||||
|
||||
var root = &cobra.Command{
|
||||
Use: "dnote",
|
||||
Short: "Dnote - a simple command line notebook",
|
||||
|
|
@ -32,6 +34,20 @@ var root = &cobra.Command{
|
|||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
root.PersistentFlags().StringVar(&apiEndpointFlag, "api-endpoint", "", "override API endpoint")
|
||||
}
|
||||
|
||||
// GetRoot returns the root command
|
||||
func GetRoot() *cobra.Command {
|
||||
return root
|
||||
}
|
||||
|
||||
// GetAPIEndpointFlag returns the value of the --api-endpoint flag
|
||||
func GetAPIEndpointFlag() string {
|
||||
return apiEndpointFlag
|
||||
}
|
||||
|
||||
// Register adds a new command
|
||||
func Register(cmd *cobra.Command) {
|
||||
root.AddCommand(cmd)
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ import (
|
|||
"github.com/dnote/dnote/pkg/cli/infra"
|
||||
"github.com/dnote/dnote/pkg/cli/log"
|
||||
"github.com/dnote/dnote/pkg/cli/migrate"
|
||||
"github.com/dnote/dnote/pkg/cli/ui"
|
||||
"github.com/dnote/dnote/pkg/cli/upgrade"
|
||||
"github.com/pkg/errors"
|
||||
"github.com/spf13/cobra"
|
||||
|
|
@ -885,6 +886,26 @@ func saveSyncState(tx *database.DB, serverTime int64, serverMaxUSN int) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// prepareEmptyServerSync marks all local books and notes as dirty when syncing to an empty server.
|
||||
// This is typically used when switching to a new empty server but wanting to upload existing local data.
|
||||
// Returns true if preparation was done, false otherwise.
|
||||
func prepareEmptyServerSync(tx *database.DB) error {
|
||||
// Mark all books and notes as dirty and reset USN to 0
|
||||
if _, err := tx.Exec("UPDATE books SET usn = 0, dirty = 1 WHERE deleted = 0"); err != nil {
|
||||
return errors.Wrap(err, "marking books as dirty")
|
||||
}
|
||||
if _, err := tx.Exec("UPDATE notes SET usn = 0, dirty = 1 WHERE deleted = 0"); err != nil {
|
||||
return errors.Wrap(err, "marking notes as dirty")
|
||||
}
|
||||
|
||||
// Reset lastMaxUSN to 0 to match the server
|
||||
if err := updateLastMaxUSN(tx, 0); err != nil {
|
||||
return errors.Wrap(err, "resetting last max usn")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func newRun(ctx context.DnoteCtx) infra.RunEFunc {
|
||||
return func(cmd *cobra.Command, args []string) error {
|
||||
if ctx.SessionKey == "" {
|
||||
|
|
@ -915,6 +936,49 @@ func newRun(ctx context.DnoteCtx) infra.RunEFunc {
|
|||
|
||||
log.Debug("lastSyncAt: %d, lastMaxUSN: %d, syncState: %+v\n", lastSyncAt, lastMaxUSN, syncState)
|
||||
|
||||
// Handle a case where server has MaxUSN=0 but local has data (server switch)
|
||||
var bookCount, noteCount int
|
||||
if err := tx.QueryRow("SELECT count(*) FROM books WHERE deleted = 0").Scan(&bookCount); err != nil {
|
||||
return errors.Wrap(err, "counting local books")
|
||||
}
|
||||
if err := tx.QueryRow("SELECT count(*) FROM notes WHERE deleted = 0").Scan(¬eCount); err != nil {
|
||||
return errors.Wrap(err, "counting local notes")
|
||||
}
|
||||
|
||||
// Only trigger empty server prompt if client has previously synced (lastMaxUSN > 0)
|
||||
// This distinguishes between first sync (lastMaxUSN=0) and server switch (lastMaxUSN>0)
|
||||
if syncState.MaxUSN == 0 && lastMaxUSN > 0 && (bookCount > 0 || noteCount > 0) {
|
||||
log.Debug("empty server detected: server.MaxUSN=%d, local.MaxUSN=%d, books=%d, notes=%d\n",
|
||||
syncState.MaxUSN, lastMaxUSN, bookCount, noteCount)
|
||||
|
||||
log.Warnf("The server is empty but you have local data.\n")
|
||||
log.Debug("server state: MaxUSN = 0 (empty)\n")
|
||||
log.Debug("local state: %d books, %d notes (MaxUSN = %d)\n", bookCount, noteCount, lastMaxUSN)
|
||||
|
||||
confirmed, err := ui.Confirm(fmt.Sprintf("Upload %d books and %d notes to the server?", bookCount, noteCount), false)
|
||||
if err != nil {
|
||||
tx.Rollback()
|
||||
return errors.Wrap(err, "getting user confirmation")
|
||||
}
|
||||
|
||||
if !confirmed {
|
||||
tx.Rollback()
|
||||
return errors.New("sync cancelled by user")
|
||||
}
|
||||
|
||||
if err := prepareEmptyServerSync(tx); err != nil {
|
||||
return errors.Wrap(err, "preparing for empty server sync")
|
||||
}
|
||||
|
||||
// Re-fetch lastMaxUSN after prepareEmptyServerSync
|
||||
lastMaxUSN, err = getLastMaxUSN(tx)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "getting the last max_usn after prepare")
|
||||
}
|
||||
|
||||
log.Debug("prepared empty server sync: marked %d books and %d notes as dirty\n", bookCount, noteCount)
|
||||
}
|
||||
|
||||
var syncErr error
|
||||
if isFullSync || lastSyncAt < syncState.FullSyncBefore {
|
||||
syncErr = fullSync(ctx, tx)
|
||||
|
|
|
|||
|
|
@ -3170,3 +3170,70 @@ func TestCleanLocalBooks(t *testing.T) {
|
|||
database.MustScan(t, "getting b3", db.QueryRow("SELECT label FROM books WHERE uuid = ?", "b3-uuid"), &b3.Label)
|
||||
database.MustScan(t, "getting b5", db.QueryRow("SELECT label FROM books WHERE uuid = ?", "b5-uuid"), &b5.Label)
|
||||
}
|
||||
|
||||
func TestPrepareEmptyServerSync(t *testing.T) {
|
||||
// set up
|
||||
db := database.InitTestDB(t, "../../tmp/.dnote", nil)
|
||||
defer database.TeardownTestDB(t, db)
|
||||
|
||||
// Setup: local has synced data (usn > 0, dirty = false) and some deleted items
|
||||
database.MustExec(t, "inserting b1", db, "INSERT INTO books (uuid, label, usn, deleted, dirty) VALUES (?, ?, ?, ?, ?)", "b1-uuid", "b1-label", 5, false, false)
|
||||
database.MustExec(t, "inserting b2", db, "INSERT INTO books (uuid, label, usn, deleted, dirty) VALUES (?, ?, ?, ?, ?)", "b2-uuid", "b2-label", 8, false, false)
|
||||
database.MustExec(t, "inserting b3 deleted", db, "INSERT INTO books (uuid, label, usn, deleted, dirty) VALUES (?, ?, ?, ?, ?)", "b3-uuid", "b3-label", 6, true, false)
|
||||
database.MustExec(t, "inserting n1", db, "INSERT INTO notes (uuid, book_uuid, body, usn, deleted, dirty, added_on) VALUES (?, ?, ?, ?, ?, ?, ?)", "n1-uuid", "b1-uuid", "note 1", 6, false, false, 1541108743)
|
||||
database.MustExec(t, "inserting n2", db, "INSERT INTO notes (uuid, book_uuid, body, usn, deleted, dirty, added_on) VALUES (?, ?, ?, ?, ?, ?, ?)", "n2-uuid", "b2-uuid", "note 2", 9, false, false, 1541108743)
|
||||
database.MustExec(t, "inserting n3 deleted", db, "INSERT INTO notes (uuid, book_uuid, body, usn, deleted, dirty, added_on) VALUES (?, ?, ?, ?, ?, ?, ?)", "n3-uuid", "b1-uuid", "note 3", 7, true, false, 1541108743)
|
||||
database.MustExec(t, "setting last_max_usn", db, "INSERT INTO system (key, value) VALUES (?, ?)", consts.SystemLastMaxUSN, 9)
|
||||
|
||||
// execute
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "beginning transaction"))
|
||||
}
|
||||
|
||||
if err := prepareEmptyServerSync(tx); err != nil {
|
||||
tx.Rollback()
|
||||
t.Fatal(errors.Wrap(err, "executing prepareEmptyServerSync"))
|
||||
}
|
||||
|
||||
tx.Commit()
|
||||
|
||||
// test - verify non-deleted items are marked dirty with usn=0, deleted items unchanged
|
||||
var b1, b2, b3 database.Book
|
||||
database.MustScan(t, "getting b1", db.QueryRow("SELECT usn, dirty, deleted FROM books WHERE uuid = ?", "b1-uuid"), &b1.USN, &b1.Dirty, &b1.Deleted)
|
||||
database.MustScan(t, "getting b2", db.QueryRow("SELECT usn, dirty, deleted FROM books WHERE uuid = ?", "b2-uuid"), &b2.USN, &b2.Dirty, &b2.Deleted)
|
||||
database.MustScan(t, "getting b3", db.QueryRow("SELECT usn, dirty, deleted FROM books WHERE uuid = ?", "b3-uuid"), &b3.USN, &b3.Dirty, &b3.Deleted)
|
||||
|
||||
assert.Equal(t, b1.USN, 0, "b1 USN should be reset to 0")
|
||||
assert.Equal(t, b1.Dirty, true, "b1 should be marked dirty")
|
||||
assert.Equal(t, b1.Deleted, false, "b1 should not be deleted")
|
||||
|
||||
assert.Equal(t, b2.USN, 0, "b2 USN should be reset to 0")
|
||||
assert.Equal(t, b2.Dirty, true, "b2 should be marked dirty")
|
||||
assert.Equal(t, b2.Deleted, false, "b2 should not be deleted")
|
||||
|
||||
assert.Equal(t, b3.USN, 6, "b3 USN should remain unchanged (deleted item)")
|
||||
assert.Equal(t, b3.Dirty, false, "b3 should not be marked dirty (deleted item)")
|
||||
assert.Equal(t, b3.Deleted, true, "b3 should remain deleted")
|
||||
|
||||
var n1, n2, n3 database.Note
|
||||
database.MustScan(t, "getting n1", db.QueryRow("SELECT usn, dirty, deleted FROM notes WHERE uuid = ?", "n1-uuid"), &n1.USN, &n1.Dirty, &n1.Deleted)
|
||||
database.MustScan(t, "getting n2", db.QueryRow("SELECT usn, dirty, deleted FROM notes WHERE uuid = ?", "n2-uuid"), &n2.USN, &n2.Dirty, &n2.Deleted)
|
||||
database.MustScan(t, "getting n3", db.QueryRow("SELECT usn, dirty, deleted FROM notes WHERE uuid = ?", "n3-uuid"), &n3.USN, &n3.Dirty, &n3.Deleted)
|
||||
|
||||
assert.Equal(t, n1.USN, 0, "n1 USN should be reset to 0")
|
||||
assert.Equal(t, n1.Dirty, true, "n1 should be marked dirty")
|
||||
assert.Equal(t, n1.Deleted, false, "n1 should not be deleted")
|
||||
|
||||
assert.Equal(t, n2.USN, 0, "n2 USN should be reset to 0")
|
||||
assert.Equal(t, n2.Dirty, true, "n2 should be marked dirty")
|
||||
assert.Equal(t, n2.Deleted, false, "n2 should not be deleted")
|
||||
|
||||
assert.Equal(t, n3.USN, 7, "n3 USN should remain unchanged (deleted item)")
|
||||
assert.Equal(t, n3.Dirty, false, "n3 should not be marked dirty (deleted item)")
|
||||
assert.Equal(t, n3.Deleted, true, "n3 should remain deleted")
|
||||
|
||||
var lastMaxUSN int
|
||||
database.MustScan(t, "getting last_max_usn", db.QueryRow("SELECT value FROM system WHERE key = ?", consts.SystemLastMaxUSN), &lastMaxUSN)
|
||||
assert.Equal(t, lastMaxUSN, 0, "last_max_usn should be reset to 0")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,10 @@ func getDBPath(paths context.Paths) string {
|
|||
return fmt.Sprintf("%s/%s/%s", paths.Data, consts.DnoteDirName, consts.DnoteDBFileName)
|
||||
}
|
||||
|
||||
func newCtx(versionTag string) (context.DnoteCtx, error) {
|
||||
// newBaseCtx creates a minimal context with paths and database connection.
|
||||
// This base context is used for file and database initialization before
|
||||
// being enriched with config values by setupCtx.
|
||||
func newBaseCtx(versionTag string) (context.DnoteCtx, error) {
|
||||
dnoteDir := getLegacyDnotePath(dirs.Home)
|
||||
paths := context.Paths{
|
||||
Home: dirs.Home,
|
||||
|
|
@ -95,8 +98,8 @@ func newCtx(versionTag string) (context.DnoteCtx, error) {
|
|||
}
|
||||
|
||||
// Init initializes the Dnote environment and returns a new dnote context
|
||||
func Init(apiEndpoint, versionTag string) (*context.DnoteCtx, error) {
|
||||
ctx, err := newCtx(versionTag)
|
||||
func Init(versionTag, apiEndpoint string) (*context.DnoteCtx, error) {
|
||||
ctx, err := newBaseCtx(versionTag)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "initializing a context")
|
||||
}
|
||||
|
|
@ -119,7 +122,7 @@ func Init(apiEndpoint, versionTag string) (*context.DnoteCtx, error) {
|
|||
return nil, errors.Wrap(err, "running migration")
|
||||
}
|
||||
|
||||
ctx, err = SetupCtx(ctx)
|
||||
ctx, err = setupCtx(ctx, apiEndpoint)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "setting up the context")
|
||||
}
|
||||
|
|
@ -129,8 +132,10 @@ func Init(apiEndpoint, versionTag string) (*context.DnoteCtx, error) {
|
|||
return &ctx, nil
|
||||
}
|
||||
|
||||
// SetupCtx populates the context and returns a new context
|
||||
func SetupCtx(ctx context.DnoteCtx) (context.DnoteCtx, error) {
|
||||
// setupCtx enriches the base context with values from config file and database.
|
||||
// This is called after files and database have been initialized.
|
||||
// If apiEndpoint is provided, it overrides the value from config.
|
||||
func setupCtx(ctx context.DnoteCtx, apiEndpoint string) (context.DnoteCtx, error) {
|
||||
db := ctx.DB
|
||||
|
||||
var sessionKey string
|
||||
|
|
@ -150,13 +155,19 @@ func SetupCtx(ctx context.DnoteCtx) (context.DnoteCtx, error) {
|
|||
return ctx, errors.Wrap(err, "reading config")
|
||||
}
|
||||
|
||||
// Use override if provided, otherwise use config value
|
||||
endpoint := cf.APIEndpoint
|
||||
if apiEndpoint != "" {
|
||||
endpoint = apiEndpoint
|
||||
}
|
||||
|
||||
ret := context.DnoteCtx{
|
||||
Paths: ctx.Paths,
|
||||
Version: ctx.Version,
|
||||
DB: ctx.DB,
|
||||
SessionKey: sessionKey,
|
||||
SessionKeyExpiry: sessionKeyExpiry,
|
||||
APIEndpoint: cf.APIEndpoint,
|
||||
APIEndpoint: endpoint,
|
||||
Editor: cf.Editor,
|
||||
Clock: clock.New(),
|
||||
EnableUpgradeCheck: cf.EnableUpgradeCheck,
|
||||
|
|
|
|||
|
|
@ -19,9 +19,12 @@
|
|||
package infra
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/dnote/dnote/pkg/assert"
|
||||
"github.com/dnote/dnote/pkg/cli/config"
|
||||
"github.com/dnote/dnote/pkg/cli/database"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
|
@ -91,3 +94,49 @@ func TestInitSystemKV_existing(t *testing.T) {
|
|||
db.QueryRow("SELECT value FROM system WHERE key = ?", "testKey"), &val)
|
||||
assert.Equal(t, val, "testVal", "system value should not have been updated")
|
||||
}
|
||||
|
||||
func TestInit_APIEndpointChange(t *testing.T) {
|
||||
// Create a temporary directory for test
|
||||
tmpDir, err := os.MkdirTemp("", "dnote-init-test-*")
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "creating temp dir"))
|
||||
}
|
||||
defer os.RemoveAll(tmpDir)
|
||||
|
||||
// Set up environment to use our temp directory
|
||||
t.Setenv("XDG_CONFIG_HOME", fmt.Sprintf("%s/config", tmpDir))
|
||||
t.Setenv("XDG_DATA_HOME", fmt.Sprintf("%s/data", tmpDir))
|
||||
t.Setenv("XDG_CACHE_HOME", fmt.Sprintf("%s/cache", tmpDir))
|
||||
|
||||
// First init.
|
||||
endpoint1 := "http://127.0.0.1:3001"
|
||||
ctx, err := Init("test-version", endpoint1)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "initializing"))
|
||||
}
|
||||
defer ctx.DB.Close()
|
||||
assert.Equal(t, ctx.APIEndpoint, endpoint1, "should use endpoint1 API endpoint")
|
||||
|
||||
// Test that config was written with endpoint1.
|
||||
cf, err := config.Read(*ctx)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "reading config"))
|
||||
}
|
||||
|
||||
// Second init with different endpoint.
|
||||
endpoint2 := "http://127.0.0.1:3002"
|
||||
ctx2, err := Init("test-version", endpoint2)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "initializing with override"))
|
||||
}
|
||||
defer ctx2.DB.Close()
|
||||
// Context must be using that endpoint.
|
||||
assert.Equal(t, ctx2.APIEndpoint, endpoint2, "should use endpoint2 API endpoint")
|
||||
|
||||
// The config file shouldn't have been modified.
|
||||
cf2, err := config.Read(*ctx2)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "reading config after override"))
|
||||
}
|
||||
assert.Equal(t, cf2.APIEndpoint, cf.APIEndpoint, "config should still have original endpoint, not endpoint2")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,7 +46,16 @@ var apiEndpoint string
|
|||
var versionTag = "master"
|
||||
|
||||
func main() {
|
||||
ctx, err := infra.Init(apiEndpoint, versionTag)
|
||||
// Parse flags early to check if --api-endpoint was provided
|
||||
root.GetRoot().ParseFlags(os.Args[1:])
|
||||
|
||||
// Use flag value if provided, otherwise use ldflags value
|
||||
endpoint := apiEndpoint
|
||||
if flagValue := root.GetAPIEndpointFlag(); flagValue != "" {
|
||||
endpoint = flagValue
|
||||
}
|
||||
|
||||
ctx, err := infra.Init(versionTag, endpoint)
|
||||
if err != nil {
|
||||
panic(errors.Wrap(err, "initializing context"))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ func TestAddNote(t *testing.T) {
|
|||
t.Run("new book", func(t *testing.T) {
|
||||
// Set up and execute
|
||||
testutils.RunDnoteCmd(t, opts, binaryName, "add", "js", "-c", "foo")
|
||||
testutils.WaitDnoteCmd(t, opts, testutils.UserContent, binaryName, "add", "js")
|
||||
testutils.MustWaitDnoteCmd(t, opts, testutils.UserContent, binaryName, "add", "js")
|
||||
|
||||
defer testutils.RemoveDir(t, testDir)
|
||||
|
||||
|
|
@ -349,7 +349,7 @@ func TestRemoveNote(t *testing.T) {
|
|||
if tc.yesFlag {
|
||||
testutils.RunDnoteCmd(t, opts, binaryName, "remove", "-y", "1")
|
||||
} else {
|
||||
testutils.WaitDnoteCmd(t, opts, testutils.UserConfirm, binaryName, "remove", "1")
|
||||
testutils.MustWaitDnoteCmd(t, opts, testutils.UserConfirm, binaryName, "remove", "1")
|
||||
}
|
||||
defer testutils.RemoveDir(t, testDir)
|
||||
|
||||
|
|
@ -436,7 +436,7 @@ func TestRemoveBook(t *testing.T) {
|
|||
if tc.yesFlag {
|
||||
testutils.RunDnoteCmd(t, opts, binaryName, "remove", "-y", "js")
|
||||
} else {
|
||||
testutils.WaitDnoteCmd(t, opts, testutils.UserConfirm, binaryName, "remove", "js")
|
||||
testutils.MustWaitDnoteCmd(t, opts, testutils.UserConfirm, binaryName, "remove", "js")
|
||||
}
|
||||
|
||||
defer testutils.RemoveDir(t, testDir)
|
||||
|
|
|
|||
|
|
@ -539,7 +539,10 @@ var lm12 = migration{
|
|||
return errors.Wrap(err, "reading config")
|
||||
}
|
||||
|
||||
cf.APIEndpoint = "https://api.getdnote.com"
|
||||
// Only set if not already configured
|
||||
if cf.APIEndpoint == "" {
|
||||
cf.APIEndpoint = "https://api.getdnote.com"
|
||||
}
|
||||
|
||||
err = config.Write(ctx, cf)
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
package testutils
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"io"
|
||||
|
|
@ -153,44 +154,107 @@ func RunDnoteCmd(t *testing.T, opts RunDnoteCmdOptions, binaryName string, arg .
|
|||
t.Logf("\n%s", stdout)
|
||||
}
|
||||
|
||||
// WaitDnoteCmd runs a dnote command and waits until the command is exited
|
||||
func WaitDnoteCmd(t *testing.T, opts RunDnoteCmdOptions, runFunc func(io.WriteCloser) error, binaryName string, arg ...string) {
|
||||
// WaitDnoteCmdOutput runs a dnote command and passes stdout to the callback.
|
||||
func WaitDnoteCmdOutput(t *testing.T, opts RunDnoteCmdOptions, runFunc func(io.WriteCloser, io.Reader) error, binaryName string, arg ...string) (string, error) {
|
||||
t.Logf("running: %s %s", binaryName, strings.Join(arg, " "))
|
||||
|
||||
cmd, stderr, stdout, err := NewDnoteCmd(opts, binaryName, arg...)
|
||||
binaryPath, err := filepath.Abs(binaryName)
|
||||
if err != nil {
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Fatal(errors.Wrap(err, "getting command").Error())
|
||||
return "", errors.Wrap(err, "getting absolute path to test binary")
|
||||
}
|
||||
|
||||
cmd := exec.Command(binaryPath, arg...)
|
||||
cmd.Env = opts.Env
|
||||
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stderr = &stderr
|
||||
|
||||
stdout, err := cmd.StdoutPipe()
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "getting stdout pipe")
|
||||
}
|
||||
|
||||
stdin, err := cmd.StdinPipe()
|
||||
if err != nil {
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Fatal(errors.Wrap(err, "getting stdin %s"))
|
||||
return "", errors.Wrap(err, "getting stdin")
|
||||
}
|
||||
defer stdin.Close()
|
||||
|
||||
// Start the program
|
||||
err = cmd.Start()
|
||||
if err != nil {
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Fatal(errors.Wrap(err, "starting command"))
|
||||
if err = cmd.Start(); err != nil {
|
||||
return "", errors.Wrap(err, "starting command")
|
||||
}
|
||||
|
||||
err = runFunc(stdin)
|
||||
var output bytes.Buffer
|
||||
tee := io.TeeReader(stdout, &output)
|
||||
|
||||
err = runFunc(stdin, tee)
|
||||
if err != nil {
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Fatal(errors.Wrap(err, "running with stdin"))
|
||||
t.Logf("\n%s", output.String())
|
||||
return output.String(), errors.Wrap(err, "running callback")
|
||||
}
|
||||
|
||||
err = cmd.Wait()
|
||||
if err != nil {
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Fatal(errors.Wrapf(err, "running command %s", stderr.String()))
|
||||
io.Copy(&output, stdout)
|
||||
|
||||
if err := cmd.Wait(); err != nil {
|
||||
t.Logf("\n%s", output.String())
|
||||
return output.String(), errors.Wrapf(err, "command failed: %s", stderr.String())
|
||||
}
|
||||
|
||||
// Print stdout if and only if test fails later
|
||||
t.Logf("\n%s", stdout)
|
||||
t.Logf("\n%s", output.String())
|
||||
return output.String(), nil
|
||||
}
|
||||
|
||||
func MustWaitDnoteCmdOutput(t *testing.T, opts RunDnoteCmdOptions, runFunc func(io.WriteCloser, io.Reader) error, binaryName string, arg ...string) string {
|
||||
output, err := WaitDnoteCmdOutput(t, opts, runFunc, binaryName, arg...)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
return output
|
||||
}
|
||||
|
||||
// WaitDnoteCmd runs a dnote command and waits until the command is exited.
|
||||
// Returns the stdout output as a string and any error that occurred.
|
||||
func WaitDnoteCmd(t *testing.T, opts RunDnoteCmdOptions, runFunc func(io.WriteCloser) error, binaryName string, arg ...string) (string, error) {
|
||||
return WaitDnoteCmdOutput(t, opts, func(stdin io.WriteCloser, stdout io.Reader) error {
|
||||
return runFunc(stdin)
|
||||
}, binaryName, arg...)
|
||||
}
|
||||
|
||||
// MustWaitDnoteCmd runs a dnote command and waits until the command is exited.
|
||||
// If there is an error, it fails the test. Returns the stdout output.
|
||||
func MustWaitDnoteCmd(t *testing.T, opts RunDnoteCmdOptions, runFunc func(io.WriteCloser) error, binaryName string, arg ...string) string {
|
||||
output, err := WaitDnoteCmd(t, opts, runFunc, binaryName, arg...)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return output
|
||||
}
|
||||
|
||||
// UserConfirm simulates confirmation from the user by writing to stdin
|
||||
func UserConfirmOutput(stdin io.WriteCloser, stdout io.Reader, expectedPrompt string) error {
|
||||
scanner := bufio.NewScanner(stdout)
|
||||
found := false
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
if strings.Contains(line, expectedPrompt) {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if err := scanner.Err(); err != nil {
|
||||
return errors.Wrap(err, "reading stdout")
|
||||
}
|
||||
if !found {
|
||||
return errors.New("expected prompt not found in stdout")
|
||||
}
|
||||
|
||||
// confirm
|
||||
if _, err := io.WriteString(stdin, "y\n"); err != nil {
|
||||
return errors.Wrap(err, "indicating confirmation in stdin")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// UserConfirm simulates confirmation from the user by writing to stdin
|
||||
|
|
@ -203,6 +267,16 @@ func UserConfirm(stdin io.WriteCloser) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// UserCancel simulates cancellation from the user by writing to stdin
|
||||
func UserCancel(stdin io.WriteCloser) error {
|
||||
// cancel
|
||||
if _, err := io.WriteString(stdin, "n\n"); err != nil {
|
||||
return errors.Wrap(err, "indicating cancellation in stdin")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// UserContent simulates content from the user by writing to stdin
|
||||
func UserContent(stdin io.WriteCloser) error {
|
||||
longText := `Lorem ipsum dolor sit amet, consectetur adipiscing elit,
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
|
|
@ -82,10 +83,9 @@ func clearTmp(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
// Set up server database - use file-based DB for e2e tests
|
||||
dbPath := fmt.Sprintf("%s/server.db", testDir)
|
||||
serverDb = apitest.InitDB(dbPath)
|
||||
// setupTestServer creates a test server with its own database
|
||||
func setupTestServer(dbPath string, serverTime time.Time) (*httptest.Server, *gorm.DB, error) {
|
||||
db := apitest.InitDB(dbPath)
|
||||
|
||||
mockClock := clock.NewMock()
|
||||
mockClock.SetNow(serverTime)
|
||||
|
|
@ -94,12 +94,24 @@ func TestMain(m *testing.M) {
|
|||
a.Clock = mockClock
|
||||
a.EmailTemplates = mailer.Templates{}
|
||||
a.EmailBackend = &apitest.MockEmailbackendImplementation{}
|
||||
a.DB = serverDb
|
||||
a.DB = db
|
||||
|
||||
server, err := controllers.NewServer(&a)
|
||||
if err != nil {
|
||||
return nil, nil, errors.Wrap(err, "initializing server")
|
||||
}
|
||||
|
||||
return server, db, nil
|
||||
}
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
// Set up server database - use file-based DB for e2e tests
|
||||
dbPath := fmt.Sprintf("%s/server.db", testDir)
|
||||
|
||||
var err error
|
||||
server, err = controllers.NewServer(&a)
|
||||
server, serverDb, err = setupTestServer(dbPath, serverTime)
|
||||
if err != nil {
|
||||
panic(errors.Wrap(err, "initializing router"))
|
||||
panic(err)
|
||||
}
|
||||
|
||||
defer server.Close()
|
||||
|
|
@ -234,6 +246,10 @@ type systemState struct {
|
|||
|
||||
// checkState compares the state of the client and the server with the given system state
|
||||
func checkState(t *testing.T, ctx context.DnoteCtx, user database.User, expected systemState) {
|
||||
checkStateWithDB(t, ctx, user, serverDb, expected)
|
||||
}
|
||||
|
||||
func checkStateWithDB(t *testing.T, ctx context.DnoteCtx, user database.User, db *gorm.DB, expected systemState) {
|
||||
clientDB := ctx.DB
|
||||
|
||||
var clientBookCount, clientNoteCount int
|
||||
|
|
@ -250,12 +266,12 @@ func checkState(t *testing.T, ctx context.DnoteCtx, user database.User, expected
|
|||
assert.Equal(t, clientLastSyncAt, expected.clientLastSyncAt, "client last_sync_at mismatch")
|
||||
|
||||
var serverBookCount, serverNoteCount int64
|
||||
apitest.MustExec(t, serverDb.Model(&database.Note{}).Count(&serverNoteCount), "counting server notes")
|
||||
apitest.MustExec(t, serverDb.Model(&database.Book{}).Count(&serverBookCount), "counting api notes")
|
||||
apitest.MustExec(t, db.Model(&database.Note{}).Count(&serverNoteCount), "counting server notes")
|
||||
apitest.MustExec(t, db.Model(&database.Book{}).Count(&serverBookCount), "counting api notes")
|
||||
assert.Equal(t, serverNoteCount, expected.serverNoteCount, "server note count mismatch")
|
||||
assert.Equal(t, serverBookCount, expected.serverBookCount, "server book count mismatch")
|
||||
var serverUser database.User
|
||||
apitest.MustExec(t, serverDb.Where("id = ?", user.ID).First(&serverUser), "finding user")
|
||||
apitest.MustExec(t, db.Where("id = ?", user.ID).First(&serverUser), "finding user")
|
||||
assert.Equal(t, serverUser.MaxUSN, expected.serverUserMaxUSN, "user max_usn mismatch")
|
||||
}
|
||||
|
||||
|
|
@ -412,7 +428,7 @@ func TestSync_oneway(t *testing.T) {
|
|||
cliDatabase.MustScan(t, "getting id of note to delete", cliDB.QueryRow("SELECT rowid FROM notes WHERE body = ?", "css2"), &nid2)
|
||||
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "edit", "js", nid, "-c", "js3-edited")
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "css", nid2)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "css", nid2)
|
||||
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css3")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css4")
|
||||
|
|
@ -777,9 +793,9 @@ func TestSync_twoway(t *testing.T) {
|
|||
var nid string
|
||||
cliDatabase.MustScan(t, "getting id of note to remove", cliDB.QueryRow("SELECT rowid FROM notes WHERE body = ?", "js3"), &nid)
|
||||
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "algorithms")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "algorithms")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css4")
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -989,7 +1005,7 @@ func TestSync_twoway(t *testing.T) {
|
|||
|
||||
// 2. on cli
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js2")
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "math", "-c", "math1")
|
||||
|
||||
var nid string
|
||||
|
|
@ -1337,7 +1353,7 @@ func TestSync(t *testing.T) {
|
|||
|
||||
// 2. on cli
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -1391,7 +1407,7 @@ func TestSync(t *testing.T) {
|
|||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
var nid string
|
||||
cliDatabase.MustScan(t, "getting id of note to remove", cliDB.QueryRow("SELECT rowid FROM notes WHERE uuid = ?", jsNote1UUID), &nid)
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -2009,7 +2025,7 @@ func TestSync(t *testing.T) {
|
|||
apiDeleteBook(t, user, jsBookUUID, "deleting js book")
|
||||
|
||||
// 4. on cli
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -2069,7 +2085,7 @@ func TestSync(t *testing.T) {
|
|||
// 4. on cli
|
||||
var nid string
|
||||
cliDatabase.MustScan(t, "getting id of note to remove", cliDB.QueryRow("SELECT rowid FROM notes WHERE body = ?", "js1"), &nid)
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -2614,7 +2630,7 @@ func TestSync(t *testing.T) {
|
|||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
var nid string
|
||||
cliDatabase.MustScan(t, "getting id of note to remove", cliDB.QueryRow("SELECT rowid FROM notes WHERE uuid = ?", jsNote1UUID), &nid)
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
|
||||
// 3. on server
|
||||
apiPatchNote(t, user, jsNote1UUID, fmt.Sprintf(`{"content": "%s"}`, "js1-edited"), "editing js note 1")
|
||||
|
|
@ -2688,7 +2704,7 @@ func TestSync(t *testing.T) {
|
|||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
var nid string
|
||||
cliDatabase.MustScan(t, "getting id of note to remove", cliDB.QueryRow("SELECT rowid FROM notes WHERE uuid = ?", jsNote1UUID), &nid)
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js", nid)
|
||||
|
||||
// 3. on server
|
||||
apiPatchNote(t, user, jsNote1UUID, fmt.Sprintf(`{"book_uuid": "%s"}`, cssBookUUID), "moving js note 1 to css book")
|
||||
|
|
@ -2989,7 +3005,7 @@ func TestSync(t *testing.T) {
|
|||
|
||||
// 2. on cli
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
|
||||
// 3. on server
|
||||
apiPatchBook(t, user, jsBookUUID, fmt.Sprintf(`{"name": "%s"}`, "js-edited"), "editing js book")
|
||||
|
|
@ -3060,7 +3076,7 @@ func TestSync(t *testing.T) {
|
|||
apiPatchNote(t, user, jsNote1UUID, fmt.Sprintf(`{"content": "%s"}`, "js1-edited"), "editing js1 note")
|
||||
|
||||
// 4. on cli
|
||||
clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
clitest.MustWaitDnoteCmd(t, dnoteCmdOpts, clitest.UserConfirm, cliBinaryName, "remove", "js")
|
||||
|
||||
return map[string]string{
|
||||
"jsBookUUID": jsBookUUID,
|
||||
|
|
@ -3862,3 +3878,555 @@ func TestFullSync(t *testing.T) {
|
|||
})
|
||||
})
|
||||
}
|
||||
|
||||
func TestSync_EmptyServer(t *testing.T) {
|
||||
emptyServerPrompt := "The server is empty but you have local data"
|
||||
emptyServerCallback := func(stdin io.WriteCloser, stdout io.Reader) error {
|
||||
return clitest.UserConfirmOutput(stdin, stdout, emptyServerPrompt)
|
||||
}
|
||||
|
||||
t.Run("sync to empty server after syncing to non-empty server", func(t *testing.T) {
|
||||
// Test server data loss/wipe scenario (disaster recovery):
|
||||
// Verify empty server detection works when the server loses all its data
|
||||
|
||||
// clean up
|
||||
apitest.ClearData(serverDb)
|
||||
defer apitest.ClearData(serverDb)
|
||||
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
user := setupUser(t, &ctx)
|
||||
|
||||
// Step 1: Create local data and sync to server
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify sync succeeded
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 2: Clear all server data to simulate switching to a completely new empty server
|
||||
apitest.ClearData(serverDb)
|
||||
// Recreate user and session (simulating a new server)
|
||||
user = setupUser(t, &ctx)
|
||||
|
||||
// Step 3: Sync again - should detect empty server and prompt user
|
||||
// User confirms with "y"
|
||||
clitest.MustWaitDnoteCmdOutput(t, dnoteCmdOpts, emptyServerCallback, cliBinaryName, "sync")
|
||||
|
||||
// Step 4: Verify data was uploaded to the empty server
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Verify the content is correct on both client and server
|
||||
var cliNote1JS, cliNote1CSS cliDatabase.Note
|
||||
var cliBookJS, cliBookCSS cliDatabase.Book
|
||||
cliDatabase.MustScan(t, "finding cliNote1JS", ctx.DB.QueryRow("SELECT uuid, body FROM notes WHERE body = ?", "js1"), &cliNote1JS.UUID, &cliNote1JS.Body)
|
||||
cliDatabase.MustScan(t, "finding cliNote1CSS", ctx.DB.QueryRow("SELECT uuid, body FROM notes WHERE body = ?", "css1"), &cliNote1CSS.UUID, &cliNote1CSS.Body)
|
||||
cliDatabase.MustScan(t, "finding cliBookJS", ctx.DB.QueryRow("SELECT uuid, label FROM books WHERE label = ?", "js"), &cliBookJS.UUID, &cliBookJS.Label)
|
||||
cliDatabase.MustScan(t, "finding cliBookCSS", ctx.DB.QueryRow("SELECT uuid, label FROM books WHERE label = ?", "css"), &cliBookCSS.UUID, &cliBookCSS.Label)
|
||||
|
||||
assert.Equal(t, cliNote1JS.Body, "js1", "js note body mismatch")
|
||||
assert.Equal(t, cliNote1CSS.Body, "css1", "css note body mismatch")
|
||||
assert.Equal(t, cliBookJS.Label, "js", "js book label mismatch")
|
||||
assert.Equal(t, cliBookCSS.Label, "css", "css book label mismatch")
|
||||
|
||||
// Verify on server side
|
||||
var serverNoteJS, serverNoteCSS database.Note
|
||||
var serverBookJS, serverBookCSS database.Book
|
||||
apitest.MustExec(t, serverDb.Where("body = ?", "js1").First(&serverNoteJS), "finding server note js1")
|
||||
apitest.MustExec(t, serverDb.Where("body = ?", "css1").First(&serverNoteCSS), "finding server note css1")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "js").First(&serverBookJS), "finding server book js")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "css").First(&serverBookCSS), "finding server book css")
|
||||
|
||||
assert.Equal(t, serverNoteJS.Body, "js1", "server js note body mismatch")
|
||||
assert.Equal(t, serverNoteCSS.Body, "css1", "server css note body mismatch")
|
||||
assert.Equal(t, serverBookJS.Label, "js", "server js book label mismatch")
|
||||
assert.Equal(t, serverBookCSS.Label, "css", "server css book label mismatch")
|
||||
})
|
||||
|
||||
t.Run("user cancels empty server prompt", func(t *testing.T) {
|
||||
// clean up
|
||||
apitest.ClearData(serverDb)
|
||||
defer apitest.ClearData(serverDb)
|
||||
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
user := setupUser(t, &ctx)
|
||||
|
||||
// Step 1: Create local data and sync to server
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify initial sync succeeded
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 2: Clear all server data
|
||||
apitest.ClearData(serverDb)
|
||||
user = setupUser(t, &ctx)
|
||||
|
||||
// Step 3: Sync again but user cancels with "n"
|
||||
output, err := clitest.WaitDnoteCmd(t, dnoteCmdOpts, clitest.UserCancel, cliBinaryName, "sync")
|
||||
if err == nil {
|
||||
t.Fatal("Expected sync to fail when user cancels, but it succeeded")
|
||||
}
|
||||
|
||||
// Verify the prompt appeared
|
||||
if !strings.Contains(output, "The server is empty but you have local data") {
|
||||
t.Fatalf("Expected empty server warning in output, got: %s", output)
|
||||
}
|
||||
|
||||
// Step 4: Verify local state unchanged (transaction rolled back)
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 0,
|
||||
serverBookCount: 0,
|
||||
serverUserMaxUSN: 0,
|
||||
})
|
||||
|
||||
// Verify items still have original USN and dirty=false
|
||||
var book cliDatabase.Book
|
||||
var note cliDatabase.Note
|
||||
cliDatabase.MustScan(t, "checking book state", ctx.DB.QueryRow("SELECT usn, dirty FROM books WHERE label = ?", "js"), &book.USN, &book.Dirty)
|
||||
cliDatabase.MustScan(t, "checking note state", ctx.DB.QueryRow("SELECT usn, dirty FROM notes WHERE body = ?", "js1"), ¬e.USN, ¬e.Dirty)
|
||||
|
||||
assert.NotEqual(t, book.USN, 0, "book USN should not be reset")
|
||||
assert.NotEqual(t, note.USN, 0, "note USN should not be reset")
|
||||
assert.Equal(t, book.Dirty, false, "book should not be marked dirty")
|
||||
assert.Equal(t, note.Dirty, false, "note should not be marked dirty")
|
||||
})
|
||||
|
||||
t.Run("all local data is marked deleted - should not upload", func(t *testing.T) {
|
||||
// Test edge case: Server MaxUSN=0, local MaxUSN>0, but all items are deleted=true
|
||||
// Should NOT prompt because there's nothing to upload
|
||||
|
||||
// clean up
|
||||
apitest.ClearData(serverDb)
|
||||
defer apitest.ClearData(serverDb)
|
||||
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
user := setupUser(t, &ctx)
|
||||
|
||||
// Step 1: Create local data and sync to server
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify initial sync succeeded
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 2: Delete all local notes and books (mark as deleted)
|
||||
cliDatabase.MustExec(t, "marking all books deleted", ctx.DB, "UPDATE books SET deleted = 1")
|
||||
cliDatabase.MustExec(t, "marking all notes deleted", ctx.DB, "UPDATE notes SET deleted = 1")
|
||||
|
||||
// Step 3: Clear server data to simulate switching to empty server
|
||||
apitest.ClearData(serverDb)
|
||||
user = setupUser(t, &ctx)
|
||||
|
||||
// Step 4: Sync - should NOT prompt because bookCount=0 and noteCount=0 (counting only deleted=0)
|
||||
// This should complete without user interaction
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify no data was uploaded (server still empty, but client still has deleted items)
|
||||
// Check server is empty
|
||||
var serverNoteCount, serverBookCount int64
|
||||
apitest.MustExec(t, serverDb.Model(&database.Note{}).Count(&serverNoteCount), "counting server notes")
|
||||
apitest.MustExec(t, serverDb.Model(&database.Book{}).Count(&serverBookCount), "counting server books")
|
||||
assert.Equal(t, serverNoteCount, int64(0), "server should have no notes")
|
||||
assert.Equal(t, serverBookCount, int64(0), "server should have no books")
|
||||
|
||||
// Check client still has the deleted items locally
|
||||
var clientNoteCount, clientBookCount int
|
||||
cliDatabase.MustScan(t, "counting client notes", ctx.DB.QueryRow("SELECT count(*) FROM notes WHERE deleted = 1"), &clientNoteCount)
|
||||
cliDatabase.MustScan(t, "counting client books", ctx.DB.QueryRow("SELECT count(*) FROM books WHERE deleted = 1"), &clientBookCount)
|
||||
assert.Equal(t, clientNoteCount, 2, "client should still have 2 deleted notes")
|
||||
assert.Equal(t, clientBookCount, 2, "client should still have 2 deleted books")
|
||||
|
||||
// Verify lastMaxUSN was reset to 0
|
||||
var lastMaxUSN int
|
||||
cliDatabase.MustScan(t, "getting lastMaxUSN", ctx.DB.QueryRow("SELECT value FROM system WHERE key = ?", consts.SystemLastMaxUSN), &lastMaxUSN)
|
||||
assert.Equal(t, lastMaxUSN, 0, "lastMaxUSN should be reset to 0")
|
||||
})
|
||||
|
||||
t.Run("race condition - other client uploads first", func(t *testing.T) {
|
||||
// Test race condition: Client A detects empty server and prompts user,
|
||||
// but while waiting for confirmation, Client B uploads the same data via API.
|
||||
//
|
||||
// Expected behavior: Client A's sync should handle the 409 conflict gracefully by:
|
||||
// 1. Detecting the 409 error when trying to CREATE books that already exist
|
||||
// 2. Running stepSync to pull the server's books (js, css)
|
||||
// 3. mergeBook renames local conflicts (js→js_2, css→css_2)
|
||||
// 4. Retrying sendChanges to upload the renamed books
|
||||
// Result: Both clients' data is preserved (4 books total)
|
||||
|
||||
// Clean up
|
||||
apitest.ClearData(serverDb)
|
||||
defer apitest.ClearData(serverDb)
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
user := setupUser(t, &ctx)
|
||||
|
||||
// Step 1: Create local data and sync to establish lastMaxUSN > 0
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify initial sync succeeded
|
||||
checkState(t, ctx, user, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 2: Clear server to simulate switching to empty server
|
||||
apitest.ClearData(serverDb)
|
||||
user = setupUser(t, &ctx)
|
||||
|
||||
// Step 3: Trigger sync which will detect empty server and prompt user
|
||||
// Inside the callback (before confirming), we simulate Client B uploading via API
|
||||
// We wait for the empty server prompt to ensure Client B uploads AFTER
|
||||
// GetSyncState but BEFORE the sync decision, creating the race condition deterministically
|
||||
raceCallback := func(stdin io.WriteCloser, stdout io.Reader) error {
|
||||
// First, wait for the prompt to ensure Client A has called GetSyncState
|
||||
// Block until stdout contains the string "The server is empty but you have local data"
|
||||
scanner := bufio.NewScanner(stdout)
|
||||
found := false
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
if strings.Contains(line, emptyServerPrompt) {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if err := scanner.Err(); err != nil {
|
||||
return errors.Wrap(err, "reading stdout")
|
||||
}
|
||||
if !found {
|
||||
return errors.New("expected prompt not found in stdout")
|
||||
}
|
||||
|
||||
// Now Client B uploads the same data via API (after GetSyncState, before sync decision)
|
||||
// This creates the race condition: Client A thinks server is empty, but Client B uploads data
|
||||
jsBookUUID := apiCreateBook(t, user, "js", "client B creating js book")
|
||||
cssBookUUID := apiCreateBook(t, user, "css", "client B creating css book")
|
||||
apiCreateNote(t, user, jsBookUUID, "js1", "client B creating js note")
|
||||
apiCreateNote(t, user, cssBookUUID, "css1", "client B creating css note")
|
||||
|
||||
// Now user confirms
|
||||
if _, err := io.WriteString(stdin, "y\n"); err != nil {
|
||||
return errors.Wrap(err, "confirming sync")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Step 4: Client A runs sync with race condition
|
||||
// Expected: This will FAIL with 409 error because Client B uploaded during the prompt
|
||||
output, err := clitest.WaitDnoteCmdOutput(t, dnoteCmdOpts, raceCallback, cliBinaryName, "sync")
|
||||
if err == nil {
|
||||
t.Fatal("Expected sync to fail with 409 conflict, but it succeeded")
|
||||
}
|
||||
// Verify output contains 409 or duplicate error
|
||||
if !strings.Contains(output, "409") && !strings.Contains(output, "duplicate") {
|
||||
t.Fatalf("Expected 409 conflict error in output, got: %s", output)
|
||||
}
|
||||
|
||||
// Step 5: Check local state after the failed sync (transaction rolled back)
|
||||
var localBookCount, localNoteCount int
|
||||
cliDatabase.MustScan(t, "counting local books after rollback", ctx.DB.QueryRow("SELECT count(*) FROM books"), &localBookCount)
|
||||
cliDatabase.MustScan(t, "counting local notes after rollback", ctx.DB.QueryRow("SELECT count(*) FROM notes"), &localNoteCount)
|
||||
t.Logf("After failed sync: local has %d books, %d notes", localBookCount, localNoteCount)
|
||||
|
||||
// List all local books
|
||||
rows, err := ctx.DB.Query("SELECT uuid, label, usn, dirty FROM books")
|
||||
if err == nil {
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var uuid, label string
|
||||
var usn int
|
||||
var dirty bool
|
||||
rows.Scan(&uuid, &label, &usn, &dirty)
|
||||
t.Logf("Local book: label=%s, usn=%d, dirty=%v, uuid=%s", label, usn, dirty, uuid)
|
||||
}
|
||||
}
|
||||
|
||||
// Step 6: Client A retries sync with --full flag to force pulling all server data
|
||||
// Note: cleanLocalBooks will delete Client A's original books because they have different UUIDs
|
||||
// than Client B's books on the server, and they're not dirty (USN != 0)
|
||||
// This means Client A's original data is lost - acceptable for this race condition edge case
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync", "--full")
|
||||
|
||||
// Verify final state - only Client B's data remains
|
||||
checkStateWithDB(t, ctx, user, serverDb, systemState{
|
||||
clientNoteCount: 2, // Only Client B's data (Client A's was cleaned up)
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 7: Verify specific books and notes - only Client B's data
|
||||
// Client A's original data was lost due to cleanLocalBooks during fullSync
|
||||
|
||||
// Verify server books - only Client B's data
|
||||
var svrBookJS, svrBookCSS database.Book
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "js").First(&svrBookJS), "finding server book 'js'")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "css").First(&svrBookCSS), "finding server book 'css'")
|
||||
|
||||
assert.Equal(t, svrBookJS.Label, "js", "server should have book 'js'")
|
||||
assert.Equal(t, svrBookCSS.Label, "css", "server should have book 'css'")
|
||||
|
||||
// Verify server notes - only Client B's data
|
||||
var svrNoteJS, svrNoteCSS database.Note
|
||||
apitest.MustExec(t, serverDb.Where("book_uuid = ? AND body = ?", svrBookJS.UUID, "js1").First(&svrNoteJS), "finding server note in 'js'")
|
||||
apitest.MustExec(t, serverDb.Where("book_uuid = ? AND body = ?", svrBookCSS.UUID, "css1").First(&svrNoteCSS), "finding server note in 'css'")
|
||||
|
||||
assert.Equal(t, svrNoteJS.Body, "js1", "note in 'js' should have body 'js1'")
|
||||
assert.Equal(t, svrNoteCSS.Body, "css1", "note in 'css' should have body 'css1'")
|
||||
|
||||
// Verify client books - should match server (Client B's data)
|
||||
var cliBookJS, cliBookCSS cliDatabase.Book
|
||||
cliDatabase.MustScan(t, "finding client book 'js'", ctx.DB.QueryRow("SELECT uuid, label, usn FROM books WHERE label = ?", "js"), &cliBookJS.UUID, &cliBookJS.Label, &cliBookJS.USN)
|
||||
cliDatabase.MustScan(t, "finding client book 'css'", ctx.DB.QueryRow("SELECT uuid, label, usn FROM books WHERE label = ?", "css"), &cliBookCSS.UUID, &cliBookCSS.Label, &cliBookCSS.USN)
|
||||
|
||||
assert.Equal(t, cliBookJS.Label, "js", "client should have book 'js'")
|
||||
assert.Equal(t, cliBookCSS.Label, "css", "client should have book 'css'")
|
||||
|
||||
// Verify client UUIDs match server UUIDs (pulled from server during stepSync)
|
||||
assert.Equal(t, cliBookJS.UUID, svrBookJS.UUID, "client 'js' UUID should match server")
|
||||
assert.Equal(t, cliBookCSS.UUID, svrBookCSS.UUID, "client 'css' UUID should match server")
|
||||
|
||||
// Verify all items have non-zero USN (synced successfully)
|
||||
assert.NotEqual(t, cliBookJS.USN, 0, "client 'js' should have non-zero USN")
|
||||
assert.NotEqual(t, cliBookCSS.USN, 0, "client 'css' should have non-zero USN")
|
||||
})
|
||||
|
||||
t.Run("sync to server A, then B, then back to A, then back to B", func(t *testing.T) {
|
||||
// Test switching between two actual servers to verify:
|
||||
// 1. Empty server detection works when switching to empty server
|
||||
// 2. No false detection when switching back to non-empty servers
|
||||
// 3. Both servers maintain independent state across multiple switches
|
||||
|
||||
// Clean up
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
// Create Server A with its own database
|
||||
dbPathA := fmt.Sprintf("%s/serverA.db", testDir)
|
||||
defer os.Remove(dbPathA)
|
||||
|
||||
serverA, serverDbA, err := setupTestServer(dbPathA, serverTime)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "setting up server A"))
|
||||
}
|
||||
defer serverA.Close()
|
||||
|
||||
// Create Server B with its own database
|
||||
dbPathB := fmt.Sprintf("%s/serverB.db", testDir)
|
||||
defer os.Remove(dbPathB)
|
||||
|
||||
serverB, serverDbB, err := setupTestServer(dbPathB, serverTime)
|
||||
if err != nil {
|
||||
t.Fatal(errors.Wrap(err, "setting up server B"))
|
||||
}
|
||||
defer serverB.Close()
|
||||
|
||||
// Step 1: Set up user on Server A and sync
|
||||
apiEndpointA := fmt.Sprintf("%s/api", serverA.URL)
|
||||
|
||||
userA := apitest.SetupUserData(serverDbA)
|
||||
apitest.SetupAccountData(serverDbA, userA, "alice@example.com", "pass1234")
|
||||
sessionA := apitest.SetupSession(serverDbA, userA)
|
||||
cliDatabase.MustExec(t, "inserting session_key", ctx.DB, "INSERT INTO system (key, value) VALUES (?, ?)", consts.SystemSessionKey, sessionA.Key)
|
||||
cliDatabase.MustExec(t, "inserting session_key_expiry", ctx.DB, "INSERT INTO system (key, value) VALUES (?, ?)", consts.SystemSessionKeyExpiry, sessionA.ExpiresAt.Unix())
|
||||
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "--api-endpoint", apiEndpointA, "sync")
|
||||
|
||||
// Verify sync to Server A succeeded
|
||||
checkStateWithDB(t, ctx, userA, serverDbA, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 2: Switch to Server B (empty) and sync
|
||||
apiEndpointB := fmt.Sprintf("%s/api", serverB.URL)
|
||||
|
||||
// Set up user on Server B
|
||||
userB := apitest.SetupUserData(serverDbB)
|
||||
apitest.SetupAccountData(serverDbB, userB, "alice@example.com", "pass1234")
|
||||
sessionB := apitest.SetupSession(serverDbB, userB)
|
||||
cliDatabase.MustExec(t, "updating session_key for B", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionB.Key, consts.SystemSessionKey)
|
||||
cliDatabase.MustExec(t, "updating session_key_expiry for B", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionB.ExpiresAt.Unix(), consts.SystemSessionKeyExpiry)
|
||||
|
||||
// Should detect empty server and prompt
|
||||
clitest.MustWaitDnoteCmdOutput(t, dnoteCmdOpts, emptyServerCallback, cliBinaryName, "--api-endpoint", apiEndpointB, "sync")
|
||||
|
||||
// Verify Server B now has data
|
||||
checkStateWithDB(t, ctx, userB, serverDbB, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 3: Switch back to Server A and sync
|
||||
cliDatabase.MustExec(t, "updating session_key back to A", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionA.Key, consts.SystemSessionKey)
|
||||
cliDatabase.MustExec(t, "updating session_key_expiry back to A", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionA.ExpiresAt.Unix(), consts.SystemSessionKeyExpiry)
|
||||
|
||||
// Should NOT trigger empty server detection (Server A has MaxUSN > 0)
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "--api-endpoint", apiEndpointA, "sync")
|
||||
|
||||
// Verify Server A still has its data
|
||||
checkStateWithDB(t, ctx, userA, serverDbA, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
|
||||
// Step 4: Switch back to Server B and sync again
|
||||
cliDatabase.MustExec(t, "updating session_key back to B", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionB.Key, consts.SystemSessionKey)
|
||||
cliDatabase.MustExec(t, "updating session_key_expiry back to B", ctx.DB, "UPDATE system SET value = ? WHERE key = ?", sessionB.ExpiresAt.Unix(), consts.SystemSessionKeyExpiry)
|
||||
|
||||
// Should NOT trigger empty server detection (Server B now has MaxUSN > 0 from Step 2)
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "--api-endpoint", apiEndpointB, "sync")
|
||||
|
||||
// Verify both servers maintain independent state
|
||||
checkStateWithDB(t, ctx, userB, serverDbB, systemState{
|
||||
clientNoteCount: 2,
|
||||
clientBookCount: 2,
|
||||
clientLastMaxUSN: 4,
|
||||
clientLastSyncAt: serverTime.Unix(),
|
||||
serverNoteCount: 2,
|
||||
serverBookCount: 2,
|
||||
serverUserMaxUSN: 4,
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func TestSync_FreshClientConcurrent(t *testing.T) {
|
||||
// Test the core issue: Fresh client (never synced, lastMaxUSN=0) syncing to a server
|
||||
// that already has data uploaded by another client.
|
||||
//
|
||||
// Scenario:
|
||||
// 1. Client A creates local notes (never synced, lastMaxUSN=0, lastSyncAt=0)
|
||||
// 2. Client B uploads same book names to server first
|
||||
// 3. Client A syncs
|
||||
//
|
||||
// Expected: Client A should pull server data first, detect duplicate book names,
|
||||
// rename local books to avoid conflicts (js→js_2), then upload successfully.
|
||||
//
|
||||
// Bug: When lastMaxUSN=0 and syncState.MaxUSN=0 (if GetSyncState is called before
|
||||
// Client B uploads), the sync logic skips stepSync and goes straight to sendChanges,
|
||||
// causing 409 "duplicate book exists" errors.
|
||||
|
||||
// Clean up
|
||||
apitest.ClearData(serverDb)
|
||||
defer apitest.ClearData(serverDb)
|
||||
clearTmp(t)
|
||||
|
||||
ctx := context.InitTestCtx(t, paths, nil)
|
||||
defer context.TeardownTestCtx(t, ctx)
|
||||
|
||||
user := setupUser(t, &ctx)
|
||||
|
||||
// Client A: Create local data (never sync)
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "js", "-c", "js1")
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "add", "css", "-c", "css1")
|
||||
|
||||
// Client B: Upload same book names to server via API
|
||||
jsBookUUID := apiCreateBook(t, user, "js", "client B creating js book")
|
||||
cssBookUUID := apiCreateBook(t, user, "css", "client B creating css book")
|
||||
apiCreateNote(t, user, jsBookUUID, "js2", "client B note")
|
||||
apiCreateNote(t, user, cssBookUUID, "css2", "client B note")
|
||||
|
||||
// Client A syncs - should handle the conflict gracefully
|
||||
// Expected: pulls server data, renames local books to js_2/css_2, uploads successfully
|
||||
clitest.RunDnoteCmd(t, dnoteCmdOpts, cliBinaryName, "sync")
|
||||
|
||||
// Verify: Should have 4 books on server (js, css from B, js_2, css_2 from A)
|
||||
var serverBookCount int64
|
||||
apitest.MustExec(t, serverDb.Model(&database.Book{}).Count(&serverBookCount), "counting server books")
|
||||
assert.Equal(t, int(serverBookCount), 4, "server should have 4 books")
|
||||
|
||||
// Verify books exist with correct names
|
||||
var svrBookJS, svrBookCSS, svrBookJS2, svrBookCSS2 database.Book
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "js").First(&svrBookJS), "finding server book 'js'")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "css").First(&svrBookCSS), "finding server book 'css'")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "js_2").First(&svrBookJS2), "finding server book 'js_2'")
|
||||
apitest.MustExec(t, serverDb.Where("label = ?", "css_2").First(&svrBookCSS2), "finding server book 'css_2'")
|
||||
|
||||
// Verify all 4 notes exist
|
||||
var serverNoteCount int64
|
||||
apitest.MustExec(t, serverDb.Model(&database.Note{}).Count(&serverNoteCount), "counting server notes")
|
||||
assert.Equal(t, int(serverNoteCount), 4, "server should have 4 notes")
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue