wallet-stack 1.0.0-alpha.121

package/src/app/saga.test.ts

@@ -0,0 +1,651 @@
+import { BIOMETRY_TYPE } from '@divvi/react-native-keychain'
+import * as RNLocalize from 'react-native-localize'
+import { expectSaga } from 'redux-saga-test-plan'
+import * as matchers from 'redux-saga-test-plan/matchers'
+import { EffectProviders, StaticProvider } from 'redux-saga-test-plan/providers'
+import { call, select } from 'redux-saga/effects'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { AppEvents } from 'src/analytics/Events'
+import { HooksEnablePreviewOrigin, WalletConnectPairingOrigin } from 'src/analytics/types'
+import {
+  appLock,
+  inAppReviewRequested,
+  openDeepLink,
+  openUrl,
+  setAppState,
+  setSupportedBiometryType,
+} from 'src/app/actions'
+import {
+  appInit,
+  handleDeepLink,
+  handleOpenUrl,
+  handleSetAppState,
+  requestInAppReview,
+} from 'src/app/saga'
+import {
+  getLastTimeBackgrounded,
+  getRequirePinOnAppOpen,
+  inAppReviewLastInteractionTimestampSelector,
+} from 'src/app/selectors'
+import { getAppConfig } from 'src/appConfig'
+import { DEEP_LINK_URL_SCHEME } from 'src/config'
+import { activeDappSelector } from 'src/dapps/selectors'
+import { FiatExchangeFlow } from 'src/fiatExchanges/types'
+import { initI18n } from 'src/i18n'
+import { currentLanguageSelector, otaTranslationsAppVersionSelector } from 'src/i18n/selectors'
+import { navigate } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { handleEnableHooksPreviewDeepLink } from 'src/positions/saga'
+import { allowHooksPreviewSelector } from 'src/positions/selectors'
+import { handlePaymentDeeplink } from 'src/send/utils'
+import { initializeSentry } from 'src/sentry/Sentry'
+import { getFeatureGate, patchUpdateStatsigUser } from 'src/statsig'
+import { StatsigFeatureGates } from 'src/statsig/types'
+import { navigateToURI } from 'src/utils/linking'
+import Logger from 'src/utils/Logger'
+import { ONE_DAY_IN_MILLIS } from 'src/utils/time'
+import { _setClientForTesting, initialiseWalletConnect } from 'src/walletConnect/saga'
+import { selectHasPendingState } from 'src/walletConnect/selectors'
+import { WalletConnectRequestType } from 'src/walletConnect/types'
+import { handleWalletConnectDeepLink } from 'src/walletConnect/walletConnect'
+import { walletAddressSelector } from 'src/web3/selectors'
+import { createMockStore } from 'test/utils'
+import { mockAccount } from 'test/values'
+
+jest.mock('src/analytics/AppAnalytics')
+jest.mock('src/sentry/Sentry')
+jest.mock('src/sentry/SentrySpanHub')
+jest.mock('src/statsig')
+jest.mock('src/positions/saga')
+jest.mock('react-native-in-app-review', () => ({
+  RequestInAppReview: () => mockRequestInAppReview(),
+  isAvailable: () => mockIsInAppReviewAvailable(),
+}))
+
+const mockRequestInAppReview = jest.fn()
+const mockIsInAppReviewAvailable = jest.fn()
+
+jest.unmock('src/pincode/authentication')
+
+jest.mock('src/i18n', () => ({
+  initI18n: jest.fn().mockResolvedValue(jest.fn()),
+  t: jest.fn(),
+}))
+
+jest.mock('src/utils/Logger')
+
+describe('handleDeepLink', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('Handles payment deep link', async () => {
+    const data = {
+      address: '0xf7f551752A78Ce650385B58364225e5ec18D96cB',
+      displayName: 'Super 8',
+      currencyCode: 'PHP',
+      amount: '500',
+      comment: '92a53156-c0f2-11ea-b3de-0242ac13000',
+    }
+
+    const params = new URLSearchParams(data)
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/pay?${params.toString()}`
+
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([
+        [matchers.call.fn(handlePaymentDeeplink), deepLink],
+        [select(walletAddressSelector), mockAccount],
+      ])
+      .run()
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'pay',
+      fullPath: '/pay',
+      query:
+        'address=0xf7f551752A78Ce650385B58364225e5ec18D96cB&displayName=Super+8&currencyCode=PHP&amount=500&comment=92a53156-c0f2-11ea-b3de-0242ac13000',
+    })
+  })
+
+  it('Handles cash in deep link', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/cashIn`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .run()
+    expect(navigate).toHaveBeenCalledWith(Screens.FiatExchangeCurrencyBottomSheet, {
+      flow: FiatExchangeFlow.CashIn,
+    })
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'cashIn',
+      fullPath: '/cashIn',
+      query: null,
+    })
+  })
+
+  it('Handles Bidali deep link if it is enabled', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/bidali`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [
+          call(getAppConfig),
+          {
+            experimental: {
+              bidali: {
+                url: 'https://example.com',
+              },
+            },
+          },
+        ],
+      ])
+      .run()
+    expect(navigate).toHaveBeenCalledWith(Screens.BidaliScreen, { currency: undefined })
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'bidali',
+      fullPath: '/bidali',
+      query: null,
+    })
+  })
+
+  it('Handles cash-in-success deep link', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/cash-in-success/simplex`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .run()
+    expect(navigate).toHaveBeenCalledWith(Screens.CashInSuccess, { provider: 'simplex' })
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'cash-in-success',
+      fullPath: '/cash-in-success/simplex',
+      query: null,
+    })
+  })
+
+  it('Handles cash-in-success deep link with query params', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/cash-in-success/simplex?isApproved=true`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .run()
+    expect(navigate).toHaveBeenCalledWith(Screens.CashInSuccess, { provider: 'simplex' })
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'cash-in-success',
+      fullPath: '/cash-in-success/simplex',
+      query: 'isApproved=true',
+    })
+  })
+
+  it('Handles openScreen deep link with safe origin', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/openScreen?screen=${Screens.FiatExchangeCurrency}&flow=CashIn`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink, true))
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .run()
+    expect(navigate).toHaveBeenCalledWith(
+      Screens.FiatExchangeCurrency,
+      expect.objectContaining({ flow: FiatExchangeFlow.CashIn })
+    )
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'openScreen',
+      fullPath: '/openScreen',
+      query: 'screen=FiatExchangeCurrency&flow=CashIn',
+    })
+  })
+
+  it('Handles openScreen deep link without safe origin', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/openScreen?screen=${Screens.FiatExchangeCurrency}&flow=CashIn`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink, false))
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .run()
+    expect(navigate).not.toHaveBeenCalled()
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'openScreen',
+      fullPath: '/openScreen',
+      query: 'screen=FiatExchangeCurrency&flow=CashIn',
+    })
+  })
+
+  it('Handles hooks enable preview links', async () => {
+    const deepLink = `${DEEP_LINK_URL_SCHEME}://wallet/hooks/enablePreview?hooksApiUrl=https://192.168.0.42:18000`
+    await expectSaga(handleDeepLink, openDeepLink(deepLink))
+      .provide([
+        [select(allowHooksPreviewSelector), true],
+        [select(walletAddressSelector), mockAccount],
+      ])
+      .run()
+
+    expect(handleEnableHooksPreviewDeepLink).toHaveBeenCalledWith(
+      deepLink,
+      HooksEnablePreviewOrigin.Deeplink
+    )
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.handle_deeplink, {
+      pathStartsWith: 'hooks',
+      fullPath: '/hooks/enablePreview',
+      query: 'hooksApiUrl=https://192.168.0.42:18000',
+    })
+  })
+})
+
+describe('WalletConnect deeplinks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    _setClientForTesting({} as any)
+  })
+
+  const connectionString = encodeURIComponent(
+    'wc:79a02f869d0f921e435a5e0643304548ebfa4a0430f9c66fe8b1a9254db7ef77@2?relay-protocol=irn&symKey=f661b0a9316a4ce0b6892bdce42bea0f45037f2c1bee9e118a3a4bc868a32a39'
+  )
+  const connectionLinks = [
+    {
+      name: 'Android',
+      link: connectionString,
+    },
+    {
+      name: 'iOS deeplink',
+      link: `${DEEP_LINK_URL_SCHEME}://wallet/wc?uri=${connectionString}`,
+    },
+    {
+      name: 'iOS universal link',
+      link: `https://valoraapp.com/wc?uri=${connectionString}`,
+    },
+  ]
+
+  it('handles loading time out for a deep link', async () => {
+    await expectSaga(handleDeepLink, openDeepLink(connectionLinks[0].link))
+      .provide([
+        [select(selectHasPendingState), false],
+        [select(activeDappSelector), null],
+        [select(walletAddressSelector), mockAccount],
+        {
+          race: () => ({ timedOut: true }),
+        },
+      ])
+      .call(handleWalletConnectDeepLink, connectionLinks[0].link)
+      .run()
+
+    expect(navigate).toHaveBeenNthCalledWith(1, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Loading,
+      origin: WalletConnectPairingOrigin.Deeplink,
+    })
+    expect(navigate).toHaveBeenNthCalledWith(2, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.TimeOut,
+    })
+  })
+
+  for (const { name, link } of connectionLinks) {
+    it(`handles ${name} connection links correctly`, async () => {
+      await expectSaga(handleDeepLink, openDeepLink(link))
+        .provide([
+          [select(selectHasPendingState), false],
+          [select(walletAddressSelector), mockAccount],
+          {
+            race: () => ({ timedOut: false }),
+          },
+        ])
+        .call(handleWalletConnectDeepLink, link)
+        .call(
+          initialiseWalletConnect,
+          decodeURIComponent(connectionString),
+          WalletConnectPairingOrigin.Deeplink
+        )
+        .run()
+      expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+        type: WalletConnectRequestType.Loading,
+        origin: WalletConnectPairingOrigin.Deeplink,
+      })
+    })
+
+    it(`handles ${name} connection links correctly when there's a pending request`, async () => {
+      await expectSaga(handleDeepLink, openDeepLink(link))
+        .provide([
+          [select(selectHasPendingState), true],
+          [select(walletAddressSelector), mockAccount],
+          {
+            race: () => ({ timedOut: false }),
+          },
+        ])
+        .call(handleWalletConnectDeepLink, link)
+        .call(
+          initialiseWalletConnect,
+          decodeURIComponent(connectionString),
+          WalletConnectPairingOrigin.Deeplink
+        )
+        .run()
+      expect(navigate).not.toHaveBeenCalled()
+    })
+  }
+
+  // action requests are incomplete URLs, wallets should handle presenting
+  // the user with the request.
+  const actionString = 'wc:1234'
+  const actionLinks = [
+    { name: 'Android', link: actionString },
+    { name: 'iOS deeplink', link: `${DEEP_LINK_URL_SCHEME}://wallet/wc?uri=${actionString}` },
+    { name: 'iOS universal link', link: `https://valoraapp.com/wc?uri=${actionString}` },
+  ]
+  for (const { name, link } of actionLinks) {
+    it(`handles ${name} action links correctly`, async () => {
+      await expectSaga(handleDeepLink, openDeepLink(link))
+        .provide([
+          [select(selectHasPendingState), false],
+          [select(walletAddressSelector), mockAccount],
+          {
+            race: () => ({ timedOut: false }),
+          },
+        ])
+        .call(handleWalletConnectDeepLink, link)
+        .not.call(initialiseWalletConnect)
+        .run()
+      expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+        type: WalletConnectRequestType.Loading,
+        origin: WalletConnectPairingOrigin.Deeplink,
+      })
+    })
+
+    it(`handles ${name} action links correctly when there's a pending request`, async () => {
+      await expectSaga(handleDeepLink, openDeepLink(link))
+        .provide([
+          [select(selectHasPendingState), true],
+          [select(walletAddressSelector), mockAccount],
+        ])
+        .call(handleWalletConnectDeepLink, link)
+        .not.call(initialiseWalletConnect)
+        .run()
+      expect(navigate).not.toHaveBeenCalled()
+    })
+  }
+})
+
+describe('handleOpenUrl', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  const httpLink = 'http://example.com'
+  const httpsLink = 'https://example.com'
+  const appLink = `${DEEP_LINK_URL_SCHEME}://something`
+  const otherDeepLink = 'other://deeplink'
+
+  describe('when openExternal is `false` or not specified', () => {
+    it('opens http links using WebViewScreen', async () => {
+      await expectSaga(handleOpenUrl, openUrl(httpLink)).not.call.fn(handleDeepLink).run()
+      expect(navigate).toHaveBeenCalledWith(Screens.WebViewScreen, { uri: httpLink })
+      expect(navigateToURI).not.toHaveBeenCalled()
+    })
+
+    it('opens http or https links using WebViewScreen', async () => {
+      await expectSaga(handleOpenUrl, openUrl(httpsLink)).not.call.fn(handleDeepLink).run()
+      expect(navigate).toHaveBeenCalledWith(Screens.WebViewScreen, { uri: httpsLink })
+      expect(navigateToURI).not.toHaveBeenCalled()
+    })
+
+    it('opens app deeplinks links directly', async () => {
+      await expectSaga(handleOpenUrl, openUrl(appLink))
+        .provide([[select(walletAddressSelector), mockAccount]])
+        .call(handleDeepLink, openDeepLink(appLink))
+        .run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).not.toHaveBeenCalled()
+    })
+
+    // openExternal is more of a preference, that's why we still open other links externally
+    // because we wouldn't know what to do with them anyway
+    it('opens other links externally', async () => {
+      await expectSaga(handleOpenUrl, openUrl(otherDeepLink)).not.call.fn(handleDeepLink).run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).toHaveBeenCalledWith(otherDeepLink)
+    })
+  })
+
+  describe('when openExternal is `true`', () => {
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it('opens http links externally', async () => {
+      await expectSaga(handleOpenUrl, openUrl(httpLink, true)).not.call.fn(handleDeepLink).run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).toHaveBeenCalledWith(httpLink)
+    })
+
+    it('opens https links externally', async () => {
+      await expectSaga(handleOpenUrl, openUrl(httpsLink, true)).not.call.fn(handleDeepLink).run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).toHaveBeenCalledWith(httpsLink)
+    })
+
+    // openExternal is more of a preference, that's why we still handle these directly
+    it('opens app deeplinks links directly', async () => {
+      await expectSaga(handleOpenUrl, openUrl(appLink, true))
+        .provide([[select(walletAddressSelector), mockAccount]])
+        .call(handleDeepLink, openDeepLink(appLink))
+        .run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).not.toHaveBeenCalled()
+    })
+
+    it('opens other links externally', async () => {
+      await expectSaga(handleOpenUrl, openUrl(otherDeepLink, true))
+        .not.call.fn(handleDeepLink)
+        .run()
+      expect(navigate).not.toHaveBeenCalled()
+      expect(navigateToURI).toHaveBeenCalledWith(otherDeepLink)
+    })
+  })
+})
+
+describe('handleSetAppState', () => {
+  describe('on app active', () => {
+    it('refreshes statsig and requires pin if pin required on app opened and do not lock period has passed', async () => {
+      await expectSaga(handleSetAppState, setAppState('active'))
+        .provide([
+          [select(getLastTimeBackgrounded), 0],
+          [select(getRequirePinOnAppOpen), true],
+        ])
+        .put(appLock())
+        .call(patchUpdateStatsigUser)
+        .run()
+    })
+
+    it('refreshes statsig and does not require pin if pin not required on app open', async () => {
+      await expectSaga(handleSetAppState, setAppState('active'))
+        .provide([
+          [select(getLastTimeBackgrounded), 0],
+          [select(getRequirePinOnAppOpen), false],
+        ])
+        .not.put(appLock())
+        .call(patchUpdateStatsigUser)
+        .run()
+    })
+
+    it('refreshes statsig and does not require pin if do not lock period has not passed', async () => {
+      await expectSaga(handleSetAppState, setAppState('active'))
+        .provide([
+          [select(getLastTimeBackgrounded), Date.now()],
+          [select(getRequirePinOnAppOpen), true],
+        ])
+        .not.put(appLock())
+        .call(patchUpdateStatsigUser)
+        .run()
+    })
+  })
+
+  describe('on app inactive', () => {
+    it('does nothing', async () => {
+      await expectSaga(handleSetAppState, setAppState('inactive'))
+        .provide([
+          [select(getLastTimeBackgrounded), 0],
+          [select(getRequirePinOnAppOpen), true],
+        ])
+        .not.put(appLock())
+        .not.call(patchUpdateStatsigUser)
+        .run()
+    })
+  })
+})
+
+describe('appInit', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  const defaultProviders: (EffectProviders | StaticProvider)[] = [
+    [
+      call(getAppConfig),
+      { experimental: { otaTranslations: { crowdinDistributionHash: 'hash' } } },
+    ],
+    [select(otaTranslationsAppVersionSelector), '1'],
+    [select(currentLanguageSelector), 'nl-NL'],
+  ]
+
+  it('should initialise the correct components, with the stored language', async () => {
+    await expectSaga(appInit)
+      .provide(defaultProviders)
+      .put(setSupportedBiometryType(BIOMETRY_TYPE.TOUCH_ID))
+      .run()
+
+    expect(initializeSentry).toHaveBeenCalledTimes(1)
+    expect(AppAnalytics.init).toHaveBeenCalledTimes(1)
+    // Ensure the right context is used
+    // Note: switch to mock.contexts[0] when we upgrade to jest >= 28
+    // See https://jestjs.io/docs/mock-function-api/#mockfnmockcontexts
+    expect(jest.mocked(AppAnalytics.init).mock.instances[0]).toBe(AppAnalytics)
+    expect(initI18n).toHaveBeenCalledWith('nl-NL', true, '1')
+  })
+
+  it('should initialise with the best language', async () => {
+    jest
+      .spyOn(RNLocalize, 'findBestLanguageTag')
+      .mockReturnValue({ languageTag: 'de-DE', isRTL: true })
+
+    await expectSaga(appInit)
+      .provide([[select(currentLanguageSelector), null], ...defaultProviders])
+      .put(setSupportedBiometryType(BIOMETRY_TYPE.TOUCH_ID))
+      .run()
+
+    expect(initializeSentry).toHaveBeenCalledTimes(1)
+    expect(AppAnalytics.init).toHaveBeenCalledTimes(1)
+    expect(initI18n).toHaveBeenCalledWith('de-DE', true, '1')
+  })
+
+  it('should initialise with the app fallback language', async () => {
+    jest.spyOn(RNLocalize, 'findBestLanguageTag').mockReturnValue(undefined)
+
+    await expectSaga(appInit)
+      .provide([[select(currentLanguageSelector), null], ...defaultProviders])
+      .put(setSupportedBiometryType(BIOMETRY_TYPE.TOUCH_ID))
+      .run()
+
+    expect(initializeSentry).toHaveBeenCalledTimes(1)
+    expect(AppAnalytics.init).toHaveBeenCalledTimes(1)
+    expect(initI18n).toHaveBeenCalledWith('en-US', true, '1')
+  })
+})
+
+describe(requestInAppReview, () => {
+  const now = 1482363367071
+
+  beforeAll(() => {
+    jest.useFakeTimers({
+      now,
+    })
+  })
+
+  const oneDayAgo = now - ONE_DAY_IN_MILLIS
+  const fourMonthsAndADayAgo = now - ONE_DAY_IN_MILLIS * 121
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it.each`
+    lastInteractionTimestamp | lastInteraction
+    ${null}                  | ${null}
+    ${fourMonthsAndADayAgo}  | ${'121 days ago'}
+  `(
+    `Should show when isAvailable: true, Last Interaction: $lastInteraction and Wallet Address: 0xTest`,
+    async ({ lastInteractionTimestamp }) => {
+      jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+        if (featureGate === StatsigFeatureGates.APP_REVIEW) {
+          return true
+        }
+        return false
+      })
+      mockIsInAppReviewAvailable.mockReturnValue(true)
+      mockRequestInAppReview.mockResolvedValue(true)
+
+      await expectSaga(requestInAppReview)
+        .withState(
+          createMockStore({
+            web3: { account: '0xTest' },
+          }).getState()
+        )
+        .provide([[select(inAppReviewLastInteractionTimestampSelector), lastInteractionTimestamp]])
+        .put(inAppReviewRequested(now))
+        .run()
+
+      expect(mockRequestInAppReview).toHaveBeenCalledTimes(1)
+      expect(AppAnalytics.track).toHaveBeenCalledTimes(1)
+      expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.in_app_review_impression)
+    }
+  )
+
+  it.each`
+    lastInteractionTimestamp | isAvailable | lastInteraction   | featureGate | walletAddress
+    ${fourMonthsAndADayAgo}  | ${false}    | ${'121 days ago'} | ${true}     | ${'0xTest'}
+    ${oneDayAgo}             | ${true}     | ${'1 day ago'}    | ${true}     | ${'0xTest'}
+    ${fourMonthsAndADayAgo}  | ${true}     | ${'121 days ago'} | ${false}    | ${'0xTest'}
+    ${fourMonthsAndADayAgo}  | ${true}     | ${'121 days ago'} | ${true}     | ${null}
+  `(
+    `Should not show when Device Available: $isAvailable, Feature Gate: $featureGate, Last Interaction: $lastInteraction and Wallet Address: $walletAddress`,
+    async ({ lastInteractionTimestamp, isAvailable, featureGate, walletAddress }) => {
+      jest.mocked(getFeatureGate).mockImplementation((gate) => {
+        if (gate === StatsigFeatureGates.APP_REVIEW) {
+          return featureGate
+        }
+        return false
+      })
+      mockIsInAppReviewAvailable.mockReturnValue(isAvailable)
+      mockRequestInAppReview.mockResolvedValue(true)
+
+      await expectSaga(requestInAppReview)
+        .withState(
+          createMockStore({
+            web3: { account: walletAddress },
+          }).getState()
+        )
+        .provide([[select(inAppReviewLastInteractionTimestampSelector), lastInteractionTimestamp]])
+        .not.put(inAppReviewRequested(expect.anything()))
+        .run()
+
+      expect(mockRequestInAppReview).not.toHaveBeenCalled()
+      expect(AppAnalytics.track).not.toHaveBeenCalled()
+    }
+  )
+
+  it('Should handle error from react-native-in-app-review', async () => {
+    jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+      if (featureGate === StatsigFeatureGates.APP_REVIEW) {
+        return true
+      }
+      return false
+    })
+    mockIsInAppReviewAvailable.mockReturnValue(true)
+    mockRequestInAppReview.mockRejectedValue(new Error('🤖💥'))
+
+    await expectSaga(requestInAppReview)
+      .withState(
+        createMockStore({
+          web3: { account: '0xTest' },
+        }).getState()
+      )
+      .provide([[select(inAppReviewLastInteractionTimestampSelector), null]])
+      .not.put(inAppReviewRequested(expect.anything()))
+      .run()
+
+    expect(AppAnalytics.track).toHaveBeenCalledTimes(1)
+    expect(AppAnalytics.track).toHaveBeenCalledWith(AppEvents.in_app_review_error, {
+      error: '🤖💥',
+    })
+    expect(Logger.error).toHaveBeenLastCalledWith(
+      'app/saga',
+      'Error while calling InAppReview.RequestInAppReview',
+      new Error('🤖💥')
+    )
+  })
+})