@juzi/wechaty 1.0.60 → 1.0.62

package/src/wechaty/wechaty-base.spec.ts

@@ -50,6 +50,7 @@ import type {
   WechatyInterface,
 }                           from '../wechaty/wechaty-impl.js'
 import { WechatySkeleton }  from './wechaty-skeleton.js'
+import { WechatyBuilder } from '../mods/mod.js'
 
 class WechatyTest extends WechatyBase {
 }
@@ -246,21 +247,30 @@ test('@event ready', async t => {
   const sandbox = sinon.createSandbox()
   const spy     = sandbox.spy()
 
+  const mockContact = puppet.mocker.createContact({ name: 'any' })
+
   wechaty.on('ready', spy)
   t.ok(spy.notCalled, 'should no ready event with new wechaty instance')
 
   await wechaty.start()
   t.ok(spy.notCalled, 'should no ready event right start wechaty started')
 
+  await puppet.mocker.login(mockContact)
   puppet.emit('ready', { data: 'test' })
+  await new Promise(resolve => {
+    setTimeout(resolve, 16 * 1000)
+  })
   t.equal(spy.callCount, 1, 'should fire ready event after puppet ready')
 
   await wechaty.stop()
   await wechaty.start()
   t.equal(spy.callCount, 1, 'should fire ready event second time after stop/start wechaty')
 
+  await puppet.mocker.login(mockContact)
   puppet.emit('ready', { data: 'test' })
-
+  await new Promise(resolve => {
+    setTimeout(resolve, 16 * 1000)
+  })
   t.equal(spy.callCount, 2, 'should fire ready event third time after stop/start wechaty')
 
   await wechaty.stop()
@@ -274,6 +284,8 @@ test('ready()', async t => {
 
   const spy = sandbox.spy()
 
+  const mockContact = puppet.mocker.createContact({ name: 'any' })
+
   wechaty.ready()
     .then(spy)
     .catch(e => t.fail('rejection: ' + e))
@@ -284,8 +296,11 @@ test('ready()', async t => {
 
   t.ok(spy.notCalled, 'should not ready after right start wechaty')
 
+  await puppet.mocker.login(mockContact)
   puppet.emit('ready', { data: 'test' })
-  await new Promise(resolve => setImmediate(resolve))
+  await new Promise(resolve => {
+    setTimeout(resolve, 16 * 1000)
+  })
   t.ok(spy.calledOnce, 'should ready after puppet ready')
 
   await wechaty.stop()
@@ -294,8 +309,11 @@ test('ready()', async t => {
     .then(spy)
     .catch(e => t.fail('rejection: ' + e))
 
+  await puppet.mocker.login(mockContact)
   puppet.emit('ready', { data: 'test' })
-  await new Promise(resolve => setImmediate(resolve))
+  await new Promise(resolve => {
+    setTimeout(resolve, 16 * 1000)
+  })
   t.ok(spy.calledTwice, 'should ready again after stop/start wechaty')
 
   await wechaty.stop()
@@ -390,3 +408,78 @@ test('WechatySkeleton: super.{start,stop}()', async t => {
   t.ok(startStub.calledOnce, 'should only call start once')
   t.ok(stopStub.calledOnce, 'should call the skeleton stop(), which means all mixin stops()s are chained correctly')
 })
+
+test('ReadyDelay', async t => {
+
+  const puppet = new PuppetMock() as any
+  const wechaty = WechatyBuilder.build({ puppet })
+
+  const mockContact = puppet.mocker.createContact({ name: 'any' })
+
+  await wechaty.start()
+
+  let loginCalled = false
+  wechaty.on('login', () => {
+    loginCalled = true
+  })
+
+  const future = new Promise<void>(resolve => {
+    wechaty.on('ready', () => {
+      if (loginCalled) {
+        t.pass('ready emitted after login')
+      } else {
+        t.fail('ready emitted before login')
+      }
+      resolve()
+    })
+  })
+
+  puppet.emit('ready')
+  await puppet.mocker.login(mockContact)
+
+  await future
+  await wechaty.stop()
+})
+
+test('ReadyMeetsLogout', async t => {
+  const puppet = new PuppetMock() as any
+  const wechaty = WechatyBuilder.build({ puppet })
+
+  const mockContact = puppet.mocker.createContact({ name: 'any' })
+
+  await wechaty.start()
+  await puppet.mocker.login(mockContact)
+
+  let readyEmitted = false
+  wechaty.on('ready', () => {
+    readyEmitted = true
+  })
+
+  puppet.emit('ready')
+  await new Promise(resolve => {
+    setTimeout(resolve, 5 * 1000)
+  })
+
+  puppet.emit('logout', { contactId: mockContact.id })
+  await new Promise(resolve => {
+    setTimeout(resolve, 15 * 1000)
+  })
+
+  t.ok(!readyEmitted, 'ready should not be emitted because puppet logout')
+
+  puppet.emit('login', { contactId: mockContact.id })
+
+  await new Promise(resolve => {
+    setTimeout(resolve, 5 * 1000)
+  })
+
+  t.ok(!readyEmitted, 'ready should not be emitted because it should wait for a new ready')
+
+  puppet.emit('ready')
+  await new Promise(resolve => {
+    setTimeout(resolve, 16 * 1000)
+  })
+  t.ok(readyEmitted, 'ready should be emitted')
+
+  await wechaty.stop()
+})

package/src/wechaty-mixins/puppet-mixin.ts

@@ -6,10 +6,11 @@ import {
   TimeoutPromiseGError,
 }                       from 'gerror'
 
-import { StateSwitch }  from 'state-switch'
-import type {
+import {
+  StateSwitch,
+  BooleanIndicator,
   StateSwitchInterface,
-}                       from 'state-switch'
+}  from 'state-switch'
 
 import { config, PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY }               from '../config.js'
 import { timestampToDate }      from '../pure-functions/timestamp-to-date.js'
@@ -57,13 +58,18 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
 
     readonly __readyState : StateSwitchInterface
 
+    __loginIndicator: BooleanIndicator
+
     __puppetMixinInited = false
 
+    __offCallbackList: (() => void)[] = []
+
     constructor (...args: any[]) {
       log.verbose('WechatyPuppetMixin', 'construct()')
       super(...args)
 
       this.__readyState = new StateSwitch('WechatyReady', { log })
+      this.__loginIndicator = new BooleanIndicator()
     }
 
     override async start (): Promise<void> {
@@ -111,6 +117,20 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
       } catch (e) {
         this.emitError(e)
       }
+
+      const loginListener = () => {
+        this.__loginIndicator.value(true)
+      }
+      this.on('login', loginListener)
+      const offLoginListener = () => this.off('login', loginListener)
+      this.__offCallbackList.push(offLoginListener)
+
+      const logoutListener = () => {
+        this.__loginIndicator.value(false)
+      }
+      this.on('logout', logoutListener)
+      const offLogoutListener = () => this.off('logout', logoutListener)
+      this.__offCallbackList.push(offLogoutListener)
     }
 
     override async stop (): Promise<void> {
@@ -134,6 +154,11 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
       log.verbose('WechatyPuppetMixin', 'stop() super.stop() ...')
       await super.stop()
       log.verbose('WechatyPuppetMixin', 'stop() super.stop() ... done')
+
+      while (this.__offCallbackList.length > 0) {
+        const func = this.__offCallbackList.pop()
+        func && func()
+      }
     }
 
     async ready (): Promise<void> {
@@ -359,11 +384,38 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
             break
 
           case 'ready':
-            puppet.on('ready', () => {
+            puppet.on('ready', async () => {
               log.silly('WechatyPuppetMixin', '__setupPuppetEvents() puppet.on(ready)')
 
-              this.emit('ready')
-              this.__readyState.active(true)
+              // ready event should be emitted 15s after login
+              let onceLogout: () => void
+              let timeout: ReturnType<typeof setTimeout> // 'NodeJS' is not defined.
+              const future = new Promise((resolve, reject) => {
+                onceLogout = () => {
+                  reject(new Error('puppet logout!'))
+                }
+                puppet.once('logout', onceLogout)
+                timeout = setTimeout(() => {
+                  reject(new Error('waiting for login timeout'))
+                }, 60 * 1000)
+                void this.__loginIndicator.ready(true).then(resolve)
+              }).finally(() => {
+                puppet.off('logout', onceLogout)
+                clearTimeout(timeout)
+              })
+
+              try {
+                await future
+                await new Promise(resolve => {
+                  setTimeout(resolve, 15 * 1000)
+                })
+                if (this.__loginIndicator.value()) {
+                  this.emit('ready')
+                  this.__readyState.active(true)
+                }
+              } catch (e) {
+                log.error(`ready ignored: ${(e as Error).message}`)
+              }
             })
             break
 
@@ -747,6 +799,8 @@ type ProtectedPropertyPuppetMixin =
   | '__puppet'
   | '__readyState'
   | '__setupPuppetEvents'
+  | '__loginIndicator'
+  | '__offCallbackList'
 
 export type {
   PuppetMixin,