Barrett Ruth
a83f500144
Problem: sync backends were hardcoded in `SYNC_BACKENDS` list in `init.lua`, auth routed directly through `oauth.google_client`, and adding a non-OAuth backend required editing multiple files. Solution: replace hardcoded list with `discover_backends()` that globs `lua/pending/sync/*.lua` at runtime. Rewrite `M.auth()` to dispatch to per-backend `auth()` methods with `vim.ui.select` fallback. Add `lua/pending/sync/s3.lua` with push/pull/sync via AWS CLI, per-task merge by `_s3_sync_id` (UUID), and `pending.S3Config` type.
311 lines
9.1 KiB
Lua
311 lines
9.1 KiB
Lua
require('spec.helpers')
|
|
|
|
local config = require('pending.config')
|
|
local util = require('pending.sync.util')
|
|
|
|
describe('s3', function()
|
|
local tmpdir
|
|
local pending
|
|
local s3
|
|
local orig_system
|
|
|
|
before_each(function()
|
|
tmpdir = vim.fn.tempname()
|
|
vim.fn.mkdir(tmpdir, 'p')
|
|
vim.g.pending = {
|
|
data_path = tmpdir .. '/tasks.json',
|
|
sync = { s3 = { bucket = 'test-bucket', key = 'test.json' } },
|
|
}
|
|
config.reset()
|
|
package.loaded['pending'] = nil
|
|
package.loaded['pending.sync.s3'] = nil
|
|
pending = require('pending')
|
|
s3 = require('pending.sync.s3')
|
|
orig_system = util.system
|
|
end)
|
|
|
|
after_each(function()
|
|
util.system = orig_system
|
|
vim.fn.delete(tmpdir, 'rf')
|
|
vim.g.pending = nil
|
|
config.reset()
|
|
package.loaded['pending'] = nil
|
|
package.loaded['pending.sync.s3'] = nil
|
|
end)
|
|
|
|
it('has correct name', function()
|
|
assert.equals('s3', s3.name)
|
|
end)
|
|
|
|
it('has auth function', function()
|
|
assert.equals('function', type(s3.auth))
|
|
end)
|
|
|
|
it('has auth_complete returning profile', function()
|
|
local completions = s3.auth_complete()
|
|
assert.is_true(vim.tbl_contains(completions, 'profile'))
|
|
end)
|
|
|
|
it('has push, pull, sync functions', function()
|
|
assert.equals('function', type(s3.push))
|
|
assert.equals('function', type(s3.pull))
|
|
assert.equals('function', type(s3.sync))
|
|
end)
|
|
|
|
it('has health function', function()
|
|
assert.equals('function', type(s3.health))
|
|
end)
|
|
|
|
describe('ensure_sync_id', function()
|
|
it('assigns a UUID-like sync id', function()
|
|
local task = { _extra = nil, modified = '2026-01-01T00:00:00Z' }
|
|
local id = s3._ensure_sync_id(task)
|
|
assert.is_not_nil(id)
|
|
assert.truthy(id:match('^%x%x%x%x%x%x%x%x%-%x%x%x%x%-%x%x%x%x%-%x%x%x%x%-%x%x%x%x%x%x%x%x%x%x%x%x$'))
|
|
assert.equals(id, task._extra['_s3_sync_id'])
|
|
end)
|
|
|
|
it('returns existing sync id without regenerating', function()
|
|
local task = {
|
|
_extra = { _s3_sync_id = 'existing-id' },
|
|
modified = '2026-01-01T00:00:00Z',
|
|
}
|
|
local id = s3._ensure_sync_id(task)
|
|
assert.equals('existing-id', id)
|
|
end)
|
|
end)
|
|
|
|
describe('auth', function()
|
|
it('reports success on valid credentials', function()
|
|
util.system = function(args)
|
|
if vim.tbl_contains(args, 'get-caller-identity') then
|
|
return { code = 0, stdout = '{"Account":"123456","Arn":"arn:aws:iam::user/test"}', stderr = '' }
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
local msg
|
|
local orig_notify = vim.notify
|
|
vim.notify = function(m)
|
|
msg = m
|
|
end
|
|
s3.auth()
|
|
vim.notify = orig_notify
|
|
assert.truthy(msg and msg:find('authenticated'))
|
|
end)
|
|
|
|
it('detects SSO expiry', function()
|
|
util.system = function(args)
|
|
if vim.tbl_contains(args, 'get-caller-identity') then
|
|
return { code = 1, stdout = '', stderr = 'Error: SSO session expired' }
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
local msg
|
|
local orig_notify = vim.notify
|
|
vim.notify = function(m)
|
|
msg = m
|
|
end
|
|
s3.auth()
|
|
vim.notify = orig_notify
|
|
assert.truthy(msg and msg:find('SSO'))
|
|
end)
|
|
|
|
it('detects missing credentials', function()
|
|
util.system = function()
|
|
return { code = 1, stdout = '', stderr = 'Unable to locate credentials' }
|
|
end
|
|
local msg
|
|
local orig_notify = vim.notify
|
|
vim.notify = function(m, level)
|
|
if level == vim.log.levels.ERROR then
|
|
msg = m
|
|
end
|
|
end
|
|
s3.auth()
|
|
vim.notify = orig_notify
|
|
assert.truthy(msg and msg:find('no AWS credentials'))
|
|
end)
|
|
end)
|
|
|
|
describe('push', function()
|
|
it('uploads store to S3', function()
|
|
local s = pending.store()
|
|
s:load()
|
|
s:add({ description = 'Test task', status = 'pending', category = 'Work', priority = 0 })
|
|
s:save()
|
|
|
|
local captured_args
|
|
util.system = function(args)
|
|
if vim.tbl_contains(args, 's3') then
|
|
captured_args = args
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
|
|
s3.push()
|
|
|
|
assert.is_not_nil(captured_args)
|
|
local joined = table.concat(captured_args, ' ')
|
|
assert.truthy(joined:find('s3://test%-bucket/test%.json'))
|
|
end)
|
|
|
|
it('errors when bucket is not configured', function()
|
|
vim.g.pending = { data_path = tmpdir .. '/tasks.json', sync = { s3 = {} } }
|
|
config.reset()
|
|
package.loaded['pending'] = nil
|
|
package.loaded['pending.sync.s3'] = nil
|
|
pending = require('pending')
|
|
s3 = require('pending.sync.s3')
|
|
|
|
local msg
|
|
local orig_notify = vim.notify
|
|
vim.notify = function(m, level)
|
|
if level == vim.log.levels.ERROR then
|
|
msg = m
|
|
end
|
|
end
|
|
s3.push()
|
|
vim.notify = orig_notify
|
|
assert.truthy(msg and msg:find('bucket is required'))
|
|
end)
|
|
end)
|
|
|
|
describe('pull merge', function()
|
|
it('merges remote tasks by sync_id', function()
|
|
local store_mod = require('pending.store')
|
|
local s = pending.store()
|
|
s:load()
|
|
local local_task = s:add({
|
|
description = 'Local task',
|
|
status = 'pending',
|
|
category = 'Work',
|
|
priority = 0,
|
|
})
|
|
local_task._extra = { _s3_sync_id = 'sync-1' }
|
|
local_task.modified = '2026-03-01T00:00:00Z'
|
|
s:save()
|
|
|
|
local remote_path = tmpdir .. '/remote.json'
|
|
local remote_store = store_mod.new(remote_path)
|
|
remote_store:load()
|
|
local remote_task = remote_store:add({
|
|
description = 'Updated remotely',
|
|
status = 'pending',
|
|
category = 'Work',
|
|
priority = 1,
|
|
})
|
|
remote_task._extra = { _s3_sync_id = 'sync-1' }
|
|
remote_task.modified = '2026-03-05T00:00:00Z'
|
|
|
|
local new_remote = remote_store:add({
|
|
description = 'New remote task',
|
|
status = 'pending',
|
|
category = 'Personal',
|
|
priority = 0,
|
|
})
|
|
new_remote._extra = { _s3_sync_id = 'sync-2' }
|
|
new_remote.modified = '2026-03-04T00:00:00Z'
|
|
remote_store:save()
|
|
|
|
util.system = function(args)
|
|
if vim.tbl_contains(args, 's3') and vim.tbl_contains(args, 'cp') then
|
|
for i, arg in ipairs(args) do
|
|
if arg:match('^s3://') then
|
|
local dest = args[i + 1]
|
|
if dest and not dest:match('^s3://') then
|
|
local src = io.open(remote_path, 'r')
|
|
local content = src:read('*a')
|
|
src:close()
|
|
local f = io.open(dest, 'w')
|
|
f:write(content)
|
|
f:close()
|
|
end
|
|
break
|
|
end
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
|
|
s3.pull()
|
|
|
|
s:load()
|
|
local tasks = s:tasks()
|
|
assert.equals(2, #tasks)
|
|
|
|
local found_updated = false
|
|
local found_new = false
|
|
for _, t in ipairs(tasks) do
|
|
if t._extra and t._extra['_s3_sync_id'] == 'sync-1' then
|
|
assert.equals('Updated remotely', t.description)
|
|
assert.equals(1, t.priority)
|
|
found_updated = true
|
|
end
|
|
if t._extra and t._extra['_s3_sync_id'] == 'sync-2' then
|
|
assert.equals('New remote task', t.description)
|
|
found_new = true
|
|
end
|
|
end
|
|
assert.is_true(found_updated)
|
|
assert.is_true(found_new)
|
|
end)
|
|
|
|
it('keeps local version when local is newer', function()
|
|
local s = pending.store()
|
|
s:load()
|
|
local local_task = s:add({
|
|
description = 'Local version',
|
|
status = 'pending',
|
|
category = 'Work',
|
|
priority = 0,
|
|
})
|
|
local_task._extra = { _s3_sync_id = 'sync-3' }
|
|
local_task.modified = '2026-03-10T00:00:00Z'
|
|
s:save()
|
|
|
|
local store_mod = require('pending.store')
|
|
local remote_path = tmpdir .. '/remote2.json'
|
|
local remote_store = store_mod.new(remote_path)
|
|
remote_store:load()
|
|
local remote_task = remote_store:add({
|
|
description = 'Older remote',
|
|
status = 'pending',
|
|
category = 'Work',
|
|
priority = 0,
|
|
})
|
|
remote_task._extra = { _s3_sync_id = 'sync-3' }
|
|
remote_task.modified = '2026-03-05T00:00:00Z'
|
|
remote_store:save()
|
|
|
|
util.system = function(args)
|
|
if vim.tbl_contains(args, 's3') and vim.tbl_contains(args, 'cp') then
|
|
for i, arg in ipairs(args) do
|
|
if arg:match('^s3://') then
|
|
local dest = args[i + 1]
|
|
if dest and not dest:match('^s3://') then
|
|
local src = io.open(remote_path, 'r')
|
|
local content = src:read('*a')
|
|
src:close()
|
|
local f = io.open(dest, 'w')
|
|
f:write(content)
|
|
f:close()
|
|
end
|
|
break
|
|
end
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
return { code = 0, stdout = '', stderr = '' }
|
|
end
|
|
|
|
s3.pull()
|
|
|
|
s:load()
|
|
local tasks = s:tasks()
|
|
assert.equals(1, #tasks)
|
|
assert.equals('Local version', tasks[1].description)
|
|
end)
|
|
end)
|
|
end)
|