@synopackageland/cli 0.5.3 → 0.6.0

package/dist/templates/native-go-vue/frontend/test/m2-provider.test.ts

@@ -1,87 +0,0 @@
-import {afterEach,expect,test,vi} from 'vitest'
-import {createM2Provider} from '../src/nas/m2-provider'
-import {M2_MAX_BYTES} from '../src/nas/m2-contract'
-const id='a'.repeat(64), signal=()=>new AbortController().signal
-const entry={path:'/home/notes.txt',name:'notes.txt',isdir:false,additional:{size:3}}
-const selection={grantId:id,folder:'/home',writable:true,user:'private',uid:'1026',cookie:'secret'}
-afterEach(()=>vi.useRealTimers())
-test('session adapter uses ctx.call exact routes, projects display data and does not forge helper intents',async()=>{
- const call=vi.fn(async(method:string)=>{
-  if(method==='nas.session.status')return {mode:'filestation-session',interactive:'session-required',background:'unavailable',validation:'local-only'}
-  if(method==='nas.discovery')return {files:null,shares:[{...entry,isdir:true}],total:101,offset:0}
-  if(method==='nas.grants.confirm')return selection
-  if(method==='nas.grants.list')return [selection]
-  if(method==='nas.files.list')return {files:[entry],total:1,offset:0}
-  if(method==='nas.files.stat')return entry
-  if(method==='nas.files.read')return {data:'AAH/',bytes:3}
-  if(method==='nas.files.create')return {created:true}
-  if(method==='nas.files.write')return {written:true}
-  return {revoked:true}
- })
- const p=createM2Provider({call:call as any})
- expect((await p.status(signal())).interactive).toBe('session-required')
- expect(await p.discovery(undefined,0,signal())).toMatchObject({nextOffset:1,entries:[{isDir:true}]})
- expect(await p.confirm('/home',true,signal())).toEqual({grantId:id,folder:'/home',writable:true})
- expect(JSON.stringify(await p.selections(signal()))).not.toMatch(/private|1026|cookie|secret/)
- expect((await p.list(id,'',0,signal())).entries[0]).toEqual({name:'notes.txt',path:'/home/notes.txt',isDir:false,bytes:3})
- expect((await p.stat(id,'notes.txt',signal())).bytes).toBe(3)
- expect(await p.read(id,'notes.txt',signal())).toEqual(new Uint8Array([0,1,255]))
- await p.create(id,'','\u5e74\u5ea6',signal());await p.upload(id,'\u5e74\u5ea6','file.bin',new Uint8Array([0,1,255]),signal());await p.revoke(id,signal())
- expect(call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:true})
- expect(call).toHaveBeenCalledWith('nas.files.write',{grantId:id,relative:'\u5e74\u5ea6',name:'file.bin',data:'AAH/'})
- expect(call.mock.calls.some(([m])=>/prepare|stream|publish|jobs/.test(m))).toBe(false)
- p.dispose()
-})
-test('input bounds refuse traversal, WebAPI delimiters and oversized upload without transport',async()=>{
- const call=vi.fn(),p=createM2Provider({call})
- for(const relative of ['/absolute','../secret','a//b','a/./b','a\\b','a,b','a"b'])await expect(p.list(id,relative,0,signal())).rejects.toEqual({code:'invalid-request'})
- for(const name of ['','..','a/b','a,b','a"b','a'.repeat(256)])await expect(p.create(id,'',name,signal())).rejects.toEqual({code:'invalid-request'})
- await expect(p.discovery(undefined,-1,signal())).rejects.toEqual({code:'invalid-request'})
- await expect(p.upload(id,'','ok',new Uint8Array(M2_MAX_BYTES+1),signal())).rejects.toEqual({code:'limit-exceeded'})
- expect(call).not.toHaveBeenCalled();p.dispose()
-})
-test('safe server errors survive without diagnostics; mutation is never retried',async()=>{
- for(const code of ['session_required','denied','not_found','conflict','commit-uncertain','invalid-request','unavailable']){
-  const call=vi.fn(async()=>{throw {code,message:'Cookie=sid /private'}}),p=createM2Provider({call})
-  await expect(p.create(id,'','new',signal())).rejects.toEqual({code})
-  expect(call).toHaveBeenCalledTimes(1);p.dispose()
- }
-})
-test('malformed pages, selections, status and bytes refuse rather than invent connectivity',async()=>{
- for(const [op,value] of [
-  ['discovery',{files:[{...entry,isdir:'yes'}],total:1,offset:0}],
-  ['discovery',{files:Array(101).fill(entry),total:101,offset:0}],
-  ['discovery',{files:[entry],total:1,offset:7}],
-  ['selections',[{...selection,writable:'yes'}]],['status',{mode:'connected',interactive:'ready'}],
-  ['read',{data:'AA==',bytes:3}],['read',{data:'@@',bytes:1}],['read',{data:'',bytes:M2_MAX_BYTES+1}],
- ] as const){
-  const p=createM2Provider({call:vi.fn(async()=>value) as any})
-  const request=op==='discovery'?p.discovery(undefined,0,signal()):op==='selections'?p.selections(signal()):op==='status'?p.status(signal()):p.read(id,'file',signal())
-  await expect(request).rejects.toEqual({code:'unavailable'});p.dispose()
- }
-})
-test('timeout or cancellation of a submitted mutation is uncertain; late callbacks cannot restore state',async()=>{
- vi.useFakeTimers()
- let resolve!:(value:unknown)=>void
- const call=vi.fn(()=>new Promise(r=>resolve=r)),p=createM2Provider({call:call as any})
- const mutation=p.upload(id,'','file',new Uint8Array(),signal())
- const checked=expect(mutation).rejects.toEqual({code:'commit-uncertain'})
- await vi.advanceTimersByTimeAsync(22000);await checked
- expect(call).toHaveBeenCalledTimes(1)
- resolve({written:true});await Promise.resolve()
- const controller=new AbortController(),read=p.list(id,'',0,controller.signal)
- const canceled=expect(read).rejects.toEqual({code:'canceled'});controller.abort();await canceled
- const late=p.confirm('/home',false,signal()),disposed=expect(late).rejects.toEqual({code:'commit-uncertain'})
- p.dispose();await disposed;resolve(selection)
- await expect(p.selections(signal())).rejects.toEqual({code:'canceled'})
-})
-
-test('malformed mutation acknowledgments and unknown transport errors are uncertain, never retryable success',async()=>{
- for(const operation of ['confirm','revoke','create','upload']as const){
-  const call=vi.fn(async()=>null),p=createM2Provider({call})
-  const request=operation==='confirm'?p.confirm('/home',false,signal()):operation==='revoke'?p.revoke(id,signal()):operation==='create'?p.create(id,'','new',signal()):p.upload(id,'','new',new Uint8Array(),signal())
-  await expect(request).rejects.toEqual({code:'commit-uncertain'});expect(call).toHaveBeenCalledTimes(1);p.dispose()
- }
- const p=createM2Provider({call:vi.fn(async()=>{throw {code:'transport_error'}})})
- await expect(p.create(id,'','new',signal())).rejects.toEqual({code:'commit-uncertain'});p.dispose()
-})

package/dist/templates/native-go-vue/frontend/test/m2-ui.test.ts

@@ -1,209 +0,0 @@
-// @vitest-environment jsdom
-import {expect,test,vi} from 'vitest'
-import {createApp,h,nextTick} from 'vue'
-import {AppRoot} from '@synopackageland/ui'
-import {mount} from '../src/m2-main'
-import M2PathPicker from '../src/nas/M2PathPicker.vue'
-import {M2_MAX_BYTES,M2ProviderKey,type M2Provider} from '../src/nas/m2-contract'
-import {m2Copy,m2Catalogs,m2ErrorCopy} from '../src/nas/m2-i18n'
-import {format} from '../src/nas/i18n'
-import {shellCopy} from '../src/shell/i18n'
-import type {Context} from '../src/context'
-vi.stubGlobal('URL',Object.assign(URL,{createObjectURL:vi.fn(()=> 'blob:local-test'),revokeObjectURL:vi.fn()}))
-const id='a'.repeat(64)
-async function settle(){for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}await new Promise(r=>setTimeout(r,25))}
-function click(root:HTMLElement,text:string){const b=[...root.querySelectorAll('button')].find(b=>b.textContent?.trim()===text||b.getAttribute('aria-label')===text);expect(b,text).toBeTruthy();b!.click()}
-function fixture(locale='en'){
- let user='normal1',selections:any[]=[],failure=''
- const reopen:Array<()=>void>=[]
- const call=vi.fn(async(method:string,args?:Record<string,unknown>)=>{
-  if(failure&&method.startsWith('nas.'))throw {code:failure,message:'Cookie=secret /private'}
-  if(method==='app.status')return {package:'SamePackage',version:'1',user,admin:false}
-  if(method==='nas.session.status')return {mode:'filestation-session',interactive:'session-required',background:'unavailable',validation:'local-only'}
-  if(method==='nas.discovery')return {files:args?.folder?[]:null,shares:args?.folder?undefined:[{name:'Home',path:'/home',isdir:true}],total:args?.folder?0:1,offset:0}
-  if(method==='nas.grants.list')return selections
-  if(method==='nas.grants.confirm'){const s={grantId:id,folder:args!.folder,writable:args!.writable};selections.push(s);return s}
-  if(method==='nas.grants.revoke'){selections=[];return {revoked:true}}
-  if(method==='nas.files.list')return {files:[{name:'notes.txt',path:'/home/notes.txt',isdir:false,additional:{size:3}}],total:1,offset:0}
-  if(method==='nas.files.stat')return {name:'notes.txt',path:'/home/notes.txt',isdir:false,additional:{size:3}}
-  if(method==='nas.files.read')return {data:'YWJj',bytes:3}
-  if(method==='nas.files.create')return {created:true}
-  if(method==='nas.files.write')return {written:true}
-  throw {code:'unknown_method'}
- })
- const ctx={locale,call,reopen(fn:()=>void){reopen.push(fn);return ()=>{}}} as Context
- const root=document.createElement('div');document.body.append(root);const app=mount(root,ctx)
- return {root,app,call,reopen,setUser(value:string){user=value},fail(code:string){failure=code},close(){app.unmount();root.remove()}}
-}
-test('the File Station build uses the same DSM sidebar with a status page',async()=>{
- const f=fixture(),copy=shellCopy('en')
- try{
-  await settle()
-  const labels=[...f.root.querySelectorAll<HTMLElement>('[data-nav-item]')].map(node=>node.textContent?.trim())
-  expect(labels).toEqual([copy.status,copy.folders])
-  expect(f.root.querySelector('h1')?.textContent?.trim()).toBe(copy.status)
-  const folders=[...f.root.querySelectorAll<HTMLElement>('[data-nav-item]')].find(node=>node.textContent?.trim()===copy.folders)!
-  folders.click();await settle()
-  expect(f.root.querySelector('h1')?.textContent?.trim()).toBe(copy.folders)
-  expect(f.root.textContent).toContain(m2Copy('en').ownPermissions)
- }finally{f.close()}
-})
-
-test('real session routes drive browse, writable consent, file actions and revoke without helper approval',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await settle();expect(f.root.textContent).toContain(copy.ownPermissions);expect(f.root.textContent).toContain(copy.unsupported)
-  click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle()
-  const checkbox=f.root.querySelector<HTMLElement>('[role=checkbox]')!;checkbox.click()
-  click(f.root,copy.confirm);await settle()
-  expect(f.call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:true})
-  click(f.root,copy.openFiles);await settle();click(f.root,copy.inspect);await settle()
-  expect(f.root.textContent).toContain('3');click(f.root,copy.read);await settle()
-  expect(f.root.textContent).toContain(copy.readComplete)
-  const labelled=(text:string)=>f.root.querySelector<HTMLElement>(`#${[...f.root.querySelectorAll('label')].find(l=>l.textContent?.startsWith(text))!.htmlFor}`)
-  expect(labelled(copy.folderName)).toBe(f.root.querySelector('input[data-folder-name]'));expect(labelled(copy.uploadFile)).toBe(f.root.querySelector('input[type=file]'))
-  const input=f.root.querySelector<HTMLInputElement>('input[data-folder-name]')!;input.value='new';input.dispatchEvent(new Event('input',{bubbles:true}));await settle()
-  click(f.root,copy.create);await settle();expect(f.call).toHaveBeenCalledWith('nas.files.create',{grantId:id,relative:'',name:'new'})
-  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
-  Object.defineProperty(upload,'files',{value:[{name:'note.bin',size:3,arrayBuffer:async()=>new Uint8Array([0,1,255]).buffer}]})
-  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle();click(f.root,copy.upload);await settle()
-  expect(f.call).toHaveBeenCalledWith('nas.files.write',{grantId:id,relative:'',name:'note.bin',data:'AAH/'})
-  click(f.root,copy.revoke);await settle();click(f.root,copy.confirmRevoke);await settle()
-  expect(f.root.textContent).toContain(copy.emptySelections)
-  expect(f.call.mock.calls.some(([m])=>/prepare|stream|publish|integration|root/.test(m))).toBe(false)
- }finally{f.close()}
-})
-test('nine catalogs contain matching placeholders and distinct recovery copy for each safe failure',async()=>{
- expect(Object.keys(m2Catalogs)).toHaveLength(9)
- for(const [locale,copy]of Object.entries(m2Catalogs)){
-  expect(Object.keys(copy).sort()).toEqual(Object.keys(m2Catalogs.en).sort())
-  for(const key of Object.keys(copy)as Array<keyof typeof copy>){expect(copy[key].trim()).not.toBe('');expect(copy[key].match(/\{\w+\}/g)??[]).toEqual(m2Catalogs.en[key].match(/\{\w+\}/g)??[])}
-  const messages=['session_required','denied','not_found','conflict','commit-uncertain'].map(code=>m2ErrorCopy({code,message:'secret'},copy))
-  expect(new Set(messages).size).toBe(5)
-  const f=fixture(locale)
-  try{await settle();expect(f.root.textContent).toContain(copy.ownPermissions);f.fail('session_required');click(f.root,copy.refresh);await settle();expect(f.root.textContent).toContain(copy.errorSession);expect(f.root.textContent).not.toContain('Cookie=secret')}
-  finally{f.close()}
- }
-})
-test('account change discards selections and pending dialogs until remount; two mounts isolate dialogs',async()=>{
- const a=fixture(),b=fixture(),copy=m2Copy('en')
- try{
-  await settle();click(a.root,copy.choose);click(b.root,copy.choose);await settle()
-  const ids=[...document.querySelectorAll('[id]')].map(n=>n.id).filter(Boolean);expect(new Set(ids).size).toBe(ids.length)
-  expect(a.root.querySelector('[role=dialog]')?.hasAttribute('aria-modal')).toBe(false)
-  a.setUser('normal2');a.reopen.forEach(fn=>fn());await settle()
-  expect(a.root.textContent).toContain(copy.accountChanged);expect(a.root.querySelector('[role=dialog]')).toBeNull()
-  expect(b.root.querySelector('[role=dialog]')).toBeTruthy()
- }finally{a.close();b.close()}
-})
-
-test('read-only selection hides mutations; cancellation never confirms and errors never auto-retry',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await settle();click(f.root,copy.choose);await settle();click(f.root,'Select Home');click(f.root,copy.cancel);await settle()
-  expect(f.call.mock.calls.some(([m])=>m==='nas.grants.confirm')).toBe(false)
-  click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle();click(f.root,copy.confirm);await settle()
-  expect(f.call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:false})
-  click(f.root,copy.openFiles);await settle()
-  expect(f.root.querySelector('input[type=file]')).toBeNull();expect(f.root.querySelector('input[data-folder-name]')).toBeNull()
-  f.fail('not_found');click(f.root,copy.inspect);await settle();expect(f.root.textContent).toContain(copy.errorNotFound)
-  expect(f.call.mock.calls.filter(([m])=>m==='nas.files.stat')).toHaveLength(1)
- }finally{f.close()}
-})
-test('late discovery is discarded on unmount; a failed refresh does not forget the original account binding',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await settle()
-  const original=f.call.getMockImplementation()!
-  f.call.mockImplementation(async(method,args)=>{if(method==='app.status')throw {code:'session_required'};return original(method,args)})
-  f.reopen.forEach(fn=>fn());await settle()
-  f.call.mockImplementation(original);f.setUser('normal2');f.reopen.forEach(fn=>fn());await settle()
-  expect(f.root.textContent).toContain(copy.accountChanged)
- }finally{f.close()}
- const g=fixture()
- await settle()
- let release!:(value:unknown)=>void
- const original=g.call.getMockImplementation()!
- g.call.mockImplementation(async(method,args)=>method==='nas.discovery'?new Promise(r=>release=r):original(method,args))
- click(g.root,copy.choose);await settle();g.app.unmount()
- release({files:null,shares:[{name:'private',path:'/private',isdir:true}],total:1,offset:0});await settle()
- expect(g.root.childElementCount).toBe(0);g.root.remove()
-})
-
-test('pending upload blocks competing folder controls and duplicate submission; uncertain outcome is actionable',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await settle();click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle()
-  const checkbox=f.root.querySelector<HTMLElement>('[role=checkbox]')!;checkbox.click()
-  click(f.root,copy.confirm);await settle();click(f.root,copy.openFiles);await settle()
-  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
-  Object.defineProperty(upload,'files',{value:[{name:'note.bin',size:3,arrayBuffer:async()=>new Uint8Array([0,1,255]).buffer}]})
-  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle()
-  let reject!:(error:unknown)=>void
-  const original=f.call.getMockImplementation()!
-  f.call.mockImplementation(async(method,args)=>method==='nas.files.write'?new Promise((_resolve,r)=>reject=r):original(method,args))
-  click(f.root,copy.upload);click(f.root,copy.upload);await settle()
-  for(const button of [...f.root.querySelectorAll('button')].filter(b=>[copy.choose,copy.revoke,copy.refresh,copy.openFiles].includes(b.textContent?.trim()??'')))expect(button.disabled).toBe(true)
-  reject({code:'commit-uncertain'});await settle()
-  expect(f.root.textContent).toContain(copy.errorUncertain)
-  expect(f.call.mock.calls.filter(([m])=>m==='nas.files.write')).toHaveLength(1)
-  expect([...f.root.querySelectorAll('button')].find(b=>b.textContent?.trim()===copy.upload)?.disabled).toBe(true)
- }finally{f.close()}
-})
-
-function mountPicker(consent?:string){
- const provider={discovery:async()=>({entries:[],nextOffset:undefined})} as unknown as M2Provider
- const root=document.createElement('div');document.body.append(root)
- const app=createApp({render:()=>h(AppRoot,{},()=>h(M2PathPicker,{open:true,locale:'en',consent}))})
- app.provide(M2ProviderKey,provider);app.config.idPrefix=`picker-${Math.random()}`;app.mount(root)
- return {root,close(){app.unmount();root.remove()}}
-}
-test('the picker shows the caller-provided consent copy and keeps the M2 copy by default',async()=>{
- const custom=mountPicker('Read once with your DSM login.');await settle()
- expect(custom.root.textContent).toContain('Read once with your DSM login.');expect(custom.root.textContent).not.toContain(m2Copy('en').consent);custom.close()
- const plain=mountPicker();await settle()
- expect(plain.root.textContent).toContain(m2Copy('en').consent);plain.close()
-})
-
-async function openFiles(f:ReturnType<typeof fixture>,locale='en'){
- const copy=m2Copy(locale)
- await settle()
- // In ko the navigation item shares the Choose button's label; the page button is the last match.
- ;[...f.root.querySelectorAll('button')].filter(b=>b.textContent?.trim()===copy.choose).at(-1)!.click();await settle();click(f.root,format(copy.select,'Home'));await settle()
- f.root.querySelector<HTMLElement>('[role=checkbox]')!.click()
- click(f.root,copy.confirm);await settle();click(f.root,copy.openFiles);await settle()
- return copy
-}
-// UI FilePicker "Choose files" per locale, written as escapes: template sources keep non-English text in catalogs only.
-const chooseFiles:Record<string,string>={en:'Choose files','zh-TW':'\u9078\u64c7\u6a94\u6848','zh-CN':'\u9009\u62e9\u6587\u4ef6',ja:'\u30d5\u30a1\u30a4\u30eb\u3092\u9078\u629e',ko:'\ud30c\uc77c \uc120\ud0dd',de:'Dateien ausw\u00e4hlen',fr:'Choisir des fichiers',es:'Elegir archivos',it:'Scegli file'}
-test.each(Object.keys(chooseFiles))('upload uses the compact UI FilePicker in %s',async locale=>{
- const f=fixture(locale)
- try{
-  const copy=await openFiles(f,locale)
-  expect(f.root.textContent).toContain(chooseFiles[locale])
-  expect(f.root.querySelectorAll('input[type=file]')).toHaveLength(1)
-  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
-  expect(upload.multiple).toBe(false)
-  expect(f.root.querySelector(`label[for="${upload.id}"]`)?.textContent).toContain(copy.uploadFile)
- }finally{f.close()}
-})
-test('an oversize file is refused with the limit message and is never uploaded',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await openFiles(f)
-  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
-  Object.defineProperty(upload,'files',{value:[new File([new Uint8Array(M2_MAX_BYTES+1)],'big.bin')]})
-  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle()
-  expect(f.root.textContent).toContain(m2ErrorCopy({code:'limit-exceeded'},copy))
-  expect([...f.root.querySelectorAll('button')].find(b=>b.textContent?.trim()===copy.upload)?.disabled).toBe(true)
-  expect(f.call.mock.calls.some(([m])=>m==='nas.files.write')).toBe(false)
- }finally{f.close()}
-})
-test('a downloaded read result is a UI Link with the file name',async()=>{
- const f=fixture(),copy=m2Copy('en')
- try{
-  await openFiles(f);click(f.root,copy.read);await settle()
-  const link=f.root.querySelector<HTMLAnchorElement>('a[download]')!
-  expect(link.textContent).toContain(copy.download);expect(link.download).toBe('notes.txt');expect(link.getAttribute('href')).toMatch(/^blob:/)
- }finally{f.close()}
-})

package/dist/templates/native-go-vue/frontend/test/nas-provider.test.ts

@@ -1,81 +0,0 @@
-import {expect, test} from 'vitest'
-import {createMockNasService} from '../src/nas/mock-provider'
-
-const signal = () => new AbortController().signal
-async function selection(provider: ReturnType<ReturnType<typeof createMockNasService>['connect']>) {
- const context = await provider.begin('user-personal', signal())
- const page = await provider.list(context.contextId, undefined, undefined, signal())
- return {context, candidate: page.entries[0]!}
-}
-
-test('two ordinary subjects cannot exchange contexts, candidates, intents or personal grants', async () => {
- const service = createMockNasService(), a = service.connect('normal1'), b = service.connect('normal2')
- const picked = await selection(a)
- await expect(b.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'denied'})
- await expect(b.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'denied'})
- const intent = await a.prepare(picked.candidate.nodeId, signal())
- await expect(b.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'denied'})
- const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
- expect(await b.grants(signal())).toEqual([])
- await expect(b.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
- expect(grant.actions).toEqual(['nas.files.list','nas.files.stat','nas.files.read'])
- expect(JSON.stringify(grant)).not.toMatch(/\/volume|uid|sessionRef/)
-})
-
-test('intent expires at 30 seconds; candidate expires at 60; cancel never creates a grant', async () => {
- let now = 1000
- const service = createMockNasService({now:() => now}), a = service.connect('normal1')
- const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
- now += 30_000
- await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'expired'})
- now += 30_000
- await expect(a.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'expired'})
- const next = await selection(a), cancelIntent = await a.prepare(next.candidate.nodeId, signal())
- await a.cancel(next.context.contextId)
- await expect(a.confirm(cancelIntent.intentId, cancelIntent.summaryDigest, signal())).rejects.toEqual({code:'canceled'})
- expect(await a.grants(signal())).toEqual([])
-})
-
-test('summary mismatch, replay, abort, role and session changes refuse; reconfirm gets a new ID', async () => {
- const service = createMockNasService(), admin = service.connect('admin'), a = service.connect('normal1')
- await expect(a.begin('app-shared', signal())).rejects.toEqual({code:'denied'})
- const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
- await expect(a.confirm(intent.intentId, '0'.repeat(64), signal())).rejects.toEqual({code:'stale'})
- const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
- await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'replay'})
- await a.revoke(grant.grantId, grant.revision, signal())
- const second = await a.prepare(picked.candidate.nodeId, signal())
- expect((await a.confirm(second.intentId, second.summaryDigest, signal())).grantId).not.toBe(grant.grantId)
- const aborted = new AbortController(); aborted.abort()
- await expect(a.begin('user-personal', aborted.signal)).rejects.toEqual({code:'canceled'})
- const context = await admin.begin('app-shared', signal()), page = await admin.list(context.contextId, undefined, undefined, signal())
- const shared = await admin.prepare(page.entries[0]!.nodeId, signal())
- service.setAdmin('admin', false)
- await expect(admin.confirm(shared.intentId, shared.summaryDigest, signal())).rejects.toEqual({code:'denied'})
- service.invalidate('normal1')
- await expect(a.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'stale'})
-})
-
-test('shared grant discovery is visible without becoming revoke authority; R and Q stay separate', async () => {
- const service = createMockNasService({drained:false}), admin = service.connect('admin'), a = service.connect('normal1')
- const ctx = await admin.begin('app-shared', signal()), page = await admin.list(ctx.contextId, undefined, undefined, signal())
- const intent = await admin.prepare(page.entries[0]!.nodeId, signal()), grant = await admin.confirm(intent.intentId, intent.summaryDigest, signal())
- expect((await a.grants(signal()))[0]?.grantId).toBe(grant.grantId)
- await expect(a.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
- expect(await admin.revoke(grant.grantId, grant.revision, signal())).toMatchObject({revoked:true,drained:false})
-})
-
-test('pagination binds cursor to actor/context/node and revision CAS rejects stale revoke',async()=> {
- const service=createMockNasService({pageSize:1}), a=service.connect('normal1'), b=service.connect('normal2')
- const {context,candidate}=await selection(a)
- const page=await a.list(context.contextId,undefined,undefined,signal())
- expect(page.entries).toHaveLength(1);expect(page.nextCursor).toBeTruthy()
- expect((await a.list(context.contextId,undefined,page.nextCursor,signal())).entries[0]!.displayName).toBe('Empty folder')
- await expect(a.list(context.contextId,candidate.nodeId,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
- await expect(b.list(context.contextId,undefined,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
- const intent=await a.prepare(candidate.nodeId,signal()), grant=await a.confirm(intent.intentId,intent.summaryDigest,signal())
- await expect(a.revoke(grant.grantId,grant.revision+1,signal())).rejects.toEqual({code:'stale'})
- service.newEpoch()
- expect((await a.grants(signal()))[0]!.effectiveState).toBe('suspended')
- await expect(a.prepare(candidate.nodeId,signal())).rejects.toEqual({code:'stale'})
-})

package/dist/templates/native-go-vue/frontend/test/nas-request.test.ts

@@ -1,21 +0,0 @@
-// @vitest-environment jsdom
-import {expect,test,vi} from 'vitest'
-import {createApp,defineComponent} from 'vue'
-import {useNasRequest} from '../src/nas/use-request'
-
-test('unresponsive discovery times out in five seconds, aborts, and ignores late metadata',async()=> {
- vi.useFakeTimers()
- let request!:ReturnType<typeof useNasRequest>
- const root=document.createElement('div')
- const app=createApp(defineComponent({setup(){request=useNasRequest();return ()=>null}}));app.mount(root)
- try {
-  let resolve!:(s:string)=>void, signal!:AbortSignal
-  const pending=request.run(s=>{signal=s;return new Promise<string>(r=>resolve=r)})
-  await vi.advanceTimersByTimeAsync(5000)
-  expect(await pending).toBeUndefined()
-  expect(request.busy.value).toBe(false);expect(signal.aborted).toBe(true)
-  expect(request.error.value).toEqual({code:'timeout'})
-  resolve('late private metadata');await Promise.resolve()
-  expect(request.error.value).toEqual({code:'timeout'})
- } finally {app.unmount();vi.useRealTimers()}
-})