mirror of
https://github.com/Permissionless-Software-Foundation/psf-memo-client.git
synced 2026-09-21 16:52:02 -07:00
Chris Troutner
6e8dcaf783
- Make PostReplyCount clickable whenever an onClick handler is provided, so posts with zero replies still open the thread modal. - Add ReplyThreadForm inside PostThreadModal with a 184-byte counter and optimistic reply rendering. - Pass wallet/profiles through RecentPosts, Profile, and PostThreadModal. - Add acceptance handlers for the new reply-thread UI scenarios. - Extend PostThreadModal CSS for the reply form. By coder.
581 lines
19 KiB
JavaScript
581 lines
19 KiB
JavaScript
/*
|
|
Project step handlers for the psf-memo-client acceptance pipeline.
|
|
|
|
These handlers connect Gherkin step text to real project behavior
|
|
(src/services/memo-post.js, src/services/new-post.js, src/services/memo-reply.js,
|
|
src/services/reply-thread-page.js, src/services/memo-set-name.js, and
|
|
src/services/set-name-page.js), driving them through small injected adapters
|
|
(a fake wallet, a fake feed, a fake thread, and a fake navigator) so the
|
|
acceptance run is deterministic and offline.
|
|
|
|
Regex matching with placeholder-name capture is the default style: a single
|
|
handler pattern captures the placeholder name (e.g. <message>) and fetches
|
|
the example value from the scenario example store.
|
|
|
|
The handlers serve specs/post-memo.feature, specs/memo-new.feature,
|
|
specs/reply-memo.feature, and specs/set-name.feature, whose wording differs
|
|
but which share the same underlying Memo action/page-controller behavior.
|
|
*/
|
|
|
|
'use strict'
|
|
|
|
const MemoPost = require('../../src/services/memo-post')
|
|
const NewPostPage = require('../../src/services/new-post')
|
|
const MemoReply = require('../../src/services/memo-reply')
|
|
const ReplyThreadPage = require('../../src/services/reply-thread-page')
|
|
const MemoSetName = require('../../src/services/memo-set-name')
|
|
const SetNamePage = require('../../src/services/set-name-page')
|
|
const AccountPage = require('../../src/services/account-page')
|
|
|
|
const MEMO_POST_PREFIX = MemoPost.MEMO_POST_PREFIX
|
|
const MEMO_REPLY_PREFIX = MemoReply.MEMO_REPLY_PREFIX
|
|
const MEMO_SET_NAME_PREFIX = MemoSetName.MEMO_SET_NAME_PREFIX
|
|
|
|
// A fake wallet exposing the minimal-slp-wallet adapter surface the app uses.
|
|
function makeWallet (address) {
|
|
const wallet = {
|
|
walletInfo: { cashAddress: address },
|
|
utxos: [],
|
|
broadcasts: [],
|
|
getUtxos: async function () {
|
|
return this.utxos
|
|
},
|
|
sendOpReturn: async function (msg, prefix) {
|
|
// Record the broadcast attempt, then fail if configured to do so.
|
|
this.broadcasts.push({ msg, prefix })
|
|
if (this.failWith) throw new Error(this.failWith)
|
|
return 'aa'.repeat(32)
|
|
}
|
|
}
|
|
return wallet
|
|
}
|
|
|
|
// A fake feed reflecting posts added to the recent posts feed.
|
|
function makeFeed () {
|
|
const posts = []
|
|
return {
|
|
posts,
|
|
addPost: (post) => posts.push(post)
|
|
}
|
|
}
|
|
|
|
// A fake profile store recording display names set for addresses.
|
|
function makeProfiles () {
|
|
const names = {}
|
|
return {
|
|
names,
|
|
setName: (addr, name) => { names[addr] = name },
|
|
getName: (addr) => names[addr] || null
|
|
}
|
|
}
|
|
|
|
// A fake thread store recording replies added to a post thread.
|
|
function makeThread () {
|
|
const replies = []
|
|
return {
|
|
rootTxid: null,
|
|
replies,
|
|
addReply: (r) => replies.push(r)
|
|
}
|
|
}
|
|
|
|
// Fresh world/state object for a single scenario execution.
|
|
function createWorld () {
|
|
const wallet = makeWallet('')
|
|
const feed = makeFeed()
|
|
const memoPost = new MemoPost({ wallet, feed })
|
|
const thread = makeThread()
|
|
const memoReply = new MemoReply({ wallet, thread })
|
|
const world = {
|
|
wallet,
|
|
feed,
|
|
thread,
|
|
memoPost,
|
|
memoReply,
|
|
currentPath: null,
|
|
menuOpen: false
|
|
}
|
|
|
|
// The New Post Page controller wraps the memo post behavior. Its navigate
|
|
// adapter updates the world's current path so navigation can be asserted.
|
|
world.newPage = new NewPostPage({
|
|
memoPost,
|
|
navigate: (path) => { world.currentPath = path },
|
|
menuLinks: []
|
|
})
|
|
|
|
// The Reply Thread Page controller wraps the memo reply behavior. It does
|
|
// not navigate on success so the user stays in the thread modal.
|
|
world.replyPage = new ReplyThreadPage({
|
|
memoReply,
|
|
navigate: () => {}
|
|
})
|
|
|
|
// The Set Name Page and Account Page controllers share a profile store so
|
|
// a name set on one page is visible on the other.
|
|
const profiles = makeProfiles()
|
|
const memoSetName = new MemoSetName({ wallet, profiles })
|
|
world.setNamePage = new SetNamePage({
|
|
memoSetName,
|
|
navigate: (path) => { world.currentPath = path }
|
|
})
|
|
world.accountPage = new AccountPage({
|
|
wallet,
|
|
profiles,
|
|
navigate: (path) => { world.currentPath = path }
|
|
})
|
|
|
|
return world
|
|
}
|
|
|
|
// Decode a raw reply payload into its parent txid (hex) and reply text.
|
|
function decodeReplyPayload (raw) {
|
|
const buf = Buffer.from(raw)
|
|
const parentTxid = buf.slice(0, 32).toString('hex')
|
|
const text = buf.slice(32).toString('utf8')
|
|
return { parentTxid, text }
|
|
}
|
|
|
|
// Handler registry. Each entry: { pattern, run }.
|
|
// run receives (match, exampleStore, world, step).
|
|
const handlers = [
|
|
{
|
|
name: 'wallet authenticated for address',
|
|
pattern: /^a wallet authenticated for the address (.+)$/,
|
|
run (m, example, world) {
|
|
world.wallet.walletInfo.cashAddress = m[1].trim()
|
|
}
|
|
},
|
|
{
|
|
name: 'wallet has spendable output',
|
|
pattern: /^the wallet has (?:a )?spendable output to pay the transaction fee$/,
|
|
run (m, example, world) {
|
|
world.wallet.utxos = [{ txid: 'utxo-for-fee', value: 100000 }]
|
|
}
|
|
},
|
|
{
|
|
name: 'viewing recent posts feed',
|
|
pattern: /^I am viewing the recent posts feed$/,
|
|
run (m, example, world) {
|
|
world.currentPath = NewPostPage.RECENT_FEED_PATH
|
|
}
|
|
},
|
|
{
|
|
name: 'wallet fails to broadcast with error',
|
|
pattern: /^the wallet fails to broadcast with the error "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
if (!(param in example)) {
|
|
throw new Error(`Missing example value for "${param}"`)
|
|
}
|
|
world.wallet.failWith = example[param]
|
|
}
|
|
},
|
|
{
|
|
name: 'navigate to path',
|
|
pattern: /^I navigate to the path (.+)$/,
|
|
run (m, example, world, step) {
|
|
const target = m[1].trim()
|
|
if (step.keyword === 'Then') {
|
|
if (world.currentPath !== target) {
|
|
throw new Error(`Expected to be on path ${target}, but current path is ${world.currentPath}.`)
|
|
}
|
|
} else {
|
|
world.currentPath = target
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'remain on path',
|
|
pattern: /^I remain on the path (.+)$/,
|
|
run (m, example, world) {
|
|
const target = m[1].trim()
|
|
if (world.currentPath !== target) {
|
|
throw new Error(`Expected to remain on path ${target}, but current path is ${world.currentPath}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'open navigation menu',
|
|
pattern: /^I open the navigation menu$/,
|
|
run (m, example, world) {
|
|
world.menuOpen = true
|
|
}
|
|
},
|
|
{
|
|
name: 'menu shows link to path',
|
|
pattern: /^the menu shows a link to the path (.+)$/,
|
|
run (m, example, world) {
|
|
const target = m[1].trim()
|
|
if (!world.newPage.hasMenuLink(target)) {
|
|
throw new Error(`Navigation menu does not link to ${target}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'compose/type memo text',
|
|
pattern: /^I (?:compose|type) a memo with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
if (!(param in example)) {
|
|
throw new Error(`Missing example value for "${param}"`)
|
|
}
|
|
world.newPage.setInput(example[param])
|
|
}
|
|
},
|
|
{
|
|
name: 'type name text',
|
|
pattern: /^I type a name with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
if (!(param in example)) {
|
|
throw new Error(`Missing example value for "${param}"`)
|
|
}
|
|
world.setNamePage.setInput(example[param])
|
|
}
|
|
},
|
|
{
|
|
name: 'submit/click post',
|
|
pattern: /^I (?:submit the memo|click the post button)$/,
|
|
async run (m, example, world) {
|
|
await world.newPage.submit()
|
|
}
|
|
},
|
|
{
|
|
name: 'submit name',
|
|
pattern: /^I submit the name$/,
|
|
async run (m, example, world) {
|
|
await world.setNamePage.submit()
|
|
}
|
|
},
|
|
{
|
|
name: 'thread modal shows reply form',
|
|
pattern: /^the thread modal shows a reply form$/,
|
|
run (m, example, world) {
|
|
// The reply form is always considered visible once the thread is open.
|
|
if (!world.replyPage) {
|
|
throw new Error('No reply page is attached to the thread.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'post with txid has no replies',
|
|
pattern: /^a post with the txid (.+) has no replies$/,
|
|
run (m, example, world) {
|
|
const txid = m[1].trim()
|
|
world.thread.rootTxid = txid
|
|
world.replyPage.setParent(txid)
|
|
// A fresh thread store already has no replies.
|
|
if (world.thread.replies.length !== 0) {
|
|
throw new Error(`Expected post ${txid} to have no replies, but it has ${world.thread.replies.length}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'click comment icon on post',
|
|
pattern: /^I click the comment icon on the post with txid (.+)$/,
|
|
run (m, example, world) {
|
|
const txid = m[1].trim()
|
|
// Opening the thread modal means setting the active thread txid.
|
|
world.thread.rootTxid = txid
|
|
world.replyPage.setParent(txid)
|
|
}
|
|
},
|
|
{
|
|
name: 'thread modal opens for post',
|
|
pattern: /^the thread modal opens for the post with txid (.+)$/,
|
|
run (m, example, world) {
|
|
const txid = m[1].trim()
|
|
if (world.thread.rootTxid !== txid) {
|
|
throw new Error(`Expected thread modal to open for ${txid}, but current thread is ${world.thread.rootTxid}.`)
|
|
}
|
|
if (!world.replyPage) {
|
|
throw new Error('Thread modal opened without a reply form page.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'open reply thread',
|
|
pattern: /^I open the thread for the post with txid (.+)$/,
|
|
run (m, example, world) {
|
|
const txid = m[1].trim()
|
|
world.thread.rootTxid = txid
|
|
world.replyPage.setParent(txid)
|
|
}
|
|
},
|
|
{
|
|
name: 'type reply text',
|
|
pattern: /^I type a reply with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
if (!(param in example)) {
|
|
throw new Error(`Missing example value for "${param}"`)
|
|
}
|
|
world.replyPage.setInput(example[param])
|
|
world.replyPage.setParent(world.thread.rootTxid)
|
|
}
|
|
},
|
|
{
|
|
name: 'type reply to nested reply',
|
|
pattern: /^I type a reply to the nested reply with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
if (!(param in example)) {
|
|
throw new Error(`Missing example value for "${param}"`)
|
|
}
|
|
world.replyPage.setInput(example[param])
|
|
if (!world.nestedTxid) {
|
|
throw new Error('No nested reply has been selected.')
|
|
}
|
|
world.replyPage.setParent(world.nestedTxid)
|
|
}
|
|
},
|
|
{
|
|
name: 'submit reply',
|
|
pattern: /^I submit the reply$/,
|
|
async run (m, example, world) {
|
|
await world.replyPage.submit()
|
|
}
|
|
},
|
|
{
|
|
name: 'thread shows nested reply',
|
|
pattern: /^the thread shows a nested reply with the txid (.+)$/,
|
|
run (m, example, world) {
|
|
const txid = m[1].trim()
|
|
world.nestedTxid = txid
|
|
world.thread.addReply({
|
|
txid,
|
|
address: 'someone-else',
|
|
text: 'nested reply',
|
|
parentTxid: world.thread.rootTxid
|
|
})
|
|
}
|
|
},
|
|
{
|
|
name: 'click Set Name button',
|
|
pattern: /^I click the Set Name button$/,
|
|
run (m, example, world) {
|
|
world.accountPage.clickSetName()
|
|
}
|
|
},
|
|
{
|
|
name: 'broadcasts/attempts OP_RETURN with Memo post prefix',
|
|
pattern: /^(?:the wallet|the app) (?:broadcasts|attempts to broadcast) an OP_RETURN transaction with the Memo post prefix$/,
|
|
run (m, example, world) {
|
|
const broadcasts = world.wallet.broadcasts
|
|
if (!broadcasts.length) {
|
|
throw new Error('No OP_RETURN transaction was broadcast.')
|
|
}
|
|
const last = broadcasts[broadcasts.length - 1]
|
|
if (last.prefix !== MEMO_POST_PREFIX) {
|
|
throw new Error(`Expected Memo post prefix ${MEMO_POST_PREFIX}, got "${last.prefix}".`)
|
|
}
|
|
if (last.msg !== world.newPage.input) {
|
|
throw new Error('Broadcast message text did not match the composed memo.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'broadcasts OP_RETURN with Memo set-name prefix',
|
|
pattern: /^the app broadcasts an OP_RETURN transaction with the Memo set-name prefix$/,
|
|
run (m, example, world) {
|
|
const broadcasts = world.wallet.broadcasts
|
|
if (!broadcasts.length) {
|
|
throw new Error('No OP_RETURN transaction was broadcast.')
|
|
}
|
|
const last = broadcasts[broadcasts.length - 1]
|
|
if (last.prefix !== MEMO_SET_NAME_PREFIX) {
|
|
throw new Error(`Expected Memo set-name prefix ${MEMO_SET_NAME_PREFIX}, got "${last.prefix}".`)
|
|
}
|
|
if (last.msg !== world.setNamePage.input) {
|
|
throw new Error('Broadcast name text did not match the typed name.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'broadcasts OP_RETURN with Memo reply prefix',
|
|
pattern: /^(?:the wallet|the app) broadcasts an OP_RETURN transaction with the Memo reply prefix$/,
|
|
run (m, example, world) {
|
|
const broadcasts = world.wallet.broadcasts
|
|
if (!broadcasts.length) {
|
|
throw new Error('No OP_RETURN transaction was broadcast.')
|
|
}
|
|
const last = broadcasts[broadcasts.length - 1]
|
|
if (last.prefix !== MEMO_REPLY_PREFIX) {
|
|
throw new Error(`Expected Memo reply prefix ${MEMO_REPLY_PREFIX}, got "${last.prefix}".`)
|
|
}
|
|
const { parentTxid, text } = decodeReplyPayload(last.msg)
|
|
if (parentTxid !== world.replyPage.parentTxid) {
|
|
throw new Error('Broadcast parent txid did not match the expected reply target.')
|
|
}
|
|
if (text !== world.replyPage.input) {
|
|
throw new Error('Broadcast reply text did not match the typed reply.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'thread shows new reply from my address',
|
|
pattern: /^the thread shows a new reply from my address with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expectedText = example[param]
|
|
const myAddress = world.wallet.walletInfo.cashAddress
|
|
const found = world.thread.replies.find(
|
|
(r) => r.text === expectedText && r.address === myAddress
|
|
)
|
|
if (!found) {
|
|
throw new Error(`Thread does not show the new reply with text "${expectedText}".`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'thread shows validation/length error',
|
|
pattern: /^the thread shows a (validation|length) error$/,
|
|
run (m, example, world) {
|
|
const kind = m[1]
|
|
const expectedCode = kind === 'validation' ? 'reply_validation' : 'reply_length'
|
|
if (world.replyPage.submitError !== expectedCode) {
|
|
throw new Error(`Expected ${expectedCode}, got ${world.replyPage.submitError}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'thread remaining byte count',
|
|
pattern: /^the thread shows a remaining byte count of <([A-Za-z0-9_]+)>$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expected = parseInt(example[param], 10)
|
|
if (Number.isNaN(expected)) {
|
|
throw new Error(`Invalid expected count for "${param}".`)
|
|
}
|
|
const actual = world.replyPage.remainingCount()
|
|
if (actual !== expected) {
|
|
throw new Error(`Expected ${expected} remaining bytes, got ${actual}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'feed shows new post from my address',
|
|
pattern: /^the feed shows a new post from my address with the text "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expectedText = example[param]
|
|
const myAddress = world.wallet.walletInfo.cashAddress
|
|
const found = world.feed.posts.find(
|
|
(p) => p.text === expectedText && p.address === myAddress
|
|
)
|
|
if (!found) {
|
|
throw new Error(`Feed does not show the new post with text "${expectedText}".`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'page shows error containing text',
|
|
pattern: /^the new post page shows an error containing "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expected = example[param]
|
|
const actual = world.newPage.broadcastError || ''
|
|
if (!actual.includes(expected)) {
|
|
throw new Error(`Expected an error containing "${expected}", got "${actual}".`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'page shows validation/length error',
|
|
pattern: /^the (?:app|new post page) shows a (validation|length) error$/,
|
|
run (m, example, world) {
|
|
const kind = m[1]
|
|
const expectedCode = kind === 'validation' ? 'memo_validation' : 'memo_length'
|
|
if (world.newPage.submitError !== expectedCode) {
|
|
throw new Error(`Expected ${expectedCode}, got ${world.newPage.submitError}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'set name page shows validation/length error',
|
|
pattern: /^the set name page shows a (validation|length) error$/,
|
|
run (m, example, world) {
|
|
const kind = m[1]
|
|
const expectedCode = kind === 'validation' ? 'name_validation' : 'name_length'
|
|
if (world.setNamePage.submitError !== expectedCode) {
|
|
throw new Error(`Expected ${expectedCode}, got ${world.setNamePage.submitError}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'remaining character count',
|
|
pattern: /^the new post page shows a remaining character count of <([A-Za-z0-9_]+)>$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expected = parseInt(example[param], 10)
|
|
if (Number.isNaN(expected)) {
|
|
throw new Error(`Invalid expected count for "${param}".`)
|
|
}
|
|
const actual = world.newPage.remainingCount()
|
|
if (actual !== expected) {
|
|
throw new Error(`Expected ${expected} remaining characters, got ${actual}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'remaining byte count',
|
|
pattern: /^the set name page shows a remaining byte count of <([A-Za-z0-9_]+)>$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expected = parseInt(example[param], 10)
|
|
if (Number.isNaN(expected)) {
|
|
throw new Error(`Invalid expected count for "${param}".`)
|
|
}
|
|
const actual = world.setNamePage.remainingCount()
|
|
if (actual !== expected) {
|
|
throw new Error(`Expected ${expected} remaining bytes, got ${actual}.`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'app does not broadcast any transaction',
|
|
pattern: /^(?:the wallet|the app) does not broadcast any transaction$/,
|
|
run (m, example, world) {
|
|
if (world.wallet.broadcasts.length !== 0) {
|
|
throw new Error('A transaction was broadcast when none was expected.')
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'account page shows name',
|
|
pattern: /^the account page shows my name as "<([A-Za-z0-9_]+)>"$/,
|
|
run (m, example, world) {
|
|
const param = m[1]
|
|
const expected = example[param]
|
|
const actual = world.accountPage.getName()
|
|
if (actual !== expected) {
|
|
throw new Error(`Expected account name "${expected}", got "${actual}".`)
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'account page shows Set Name button',
|
|
pattern: /^the account page shows a Set Name button$/,
|
|
run (m, example, world) {
|
|
if (!world.accountPage.hasSetNameButton()) {
|
|
throw new Error('Account page does not show a Set Name button.')
|
|
}
|
|
}
|
|
}
|
|
]
|
|
|
|
// Route a single step to its handler. Throws on unsupported step text.
|
|
async function handleStep (step, example, world) {
|
|
for (const handler of handlers) {
|
|
const match = handler.pattern.exec(step.text)
|
|
if (match) {
|
|
await handler.run(match, example, world, step)
|
|
return
|
|
}
|
|
}
|
|
throw new Error(`Unsupported step: ${step.keyword} ${step.text}`)
|
|
}
|
|
|
|
module.exports = { createWorld, handleStep }
|