@planningcenter/chat-react-native 4.3.0-rc.9 → 4.3.1-qa-989.0

package/src/utils/__tests__/response_error.test.ts

@@ -53,8 +53,13 @@ describe('throwResponseError', () => {
     expect(() => throwResponseError(fetchResponseLike(401))).toThrow(ResponseError)
   })
 
-  it('passes through non-response errors untouched', async () => {
+  it('rethrows non-response errors synchronously instead of returning a rejected promise', () => {
     const error = new Error('network down')
-    await expect(throwResponseError(error)).rejects.toBe(error)
+    expect(() => throwResponseError(error)).toThrow(error)
+  })
+
+  it('rethrows an existing ResponseError without re-wrapping it', () => {
+    const error = new ResponseError(fetchResponseLike(401) as never)
+    expect(() => throwResponseError(error)).toThrow(error)
   })
 })

package/src/utils/client/__tests__/request_helpers.test.ts

@@ -0,0 +1,40 @@
+import { instrumentedFetch } from '../instrumented_fetch'
+import { makeRequest } from '../request_helpers'
+
+jest.mock('../instrumented_fetch', () => ({ instrumentedFetch: jest.fn() }))
+
+const mockFetch = jest.mocked(instrumentedFetch)
+
+const fetchedUrl = () => new URL(mockFetch.mock.calls[0][0])
+
+const get = (data: Record<string, unknown>) =>
+  makeRequest({ action: 'GET', url: 'https://api.example.com/search_results', data, headers: {} })
+
+describe('makeRequest', () => {
+  beforeEach(() => {
+    mockFetch.mockResolvedValue(new Response('{}', { status: 200 }))
+  })
+
+  afterEach(() => {
+    mockFetch.mockReset()
+  })
+
+  it('serializes data as snake_case query params', async () => {
+    await get({ q: 'potluck', perPage: 20 })
+
+    const { searchParams } = fetchedUrl()
+    expect(searchParams.get('q')).toBe('potluck')
+    expect(searchParams.get('per_page')).toBe('20')
+  })
+
+  it.each(['Pastor Bob', 'café', '#potluck', 'Q&A', '100%'])(
+    'sends %p so the server reads it back unchanged',
+    async term => {
+      await get({ q: term })
+
+      const { search, searchParams } = fetchedUrl()
+      expect(searchParams.get('q')).toBe(term)
+      expect(() => decodeURIComponent(search)).not.toThrow()
+    }
+  )
+})

package/src/utils/client/request_helpers.ts

@@ -33,7 +33,7 @@ export const makeRequest = ({ action = 'GET', url, data = {}, headers = {} }: Ma
 
   const body = ['POST', 'PATCH'].includes(action) ? JSON.stringify(data) : undefined
 
-  return instrumentedFetch(decodeURIComponent(uri.toString()), {
+  return instrumentedFetch(uri.toString(), {
     method: action,
     headers,
     body,

package/src/utils/native_adapters/__tests__/linking.test.ts

@@ -0,0 +1,12 @@
+import { LinkingAdapter } from '../linking'
+
+describe('LinkingAdapter', () => {
+  it('forwards open options to the host', async () => {
+    const openURL = jest.fn(async () => {})
+    const adapter = new LinkingAdapter({ openURL, canOpenURL: async () => true })
+
+    await adapter.openURL('https://example.com', { forceOpenInBrowser: true })
+
+    expect(openURL).toHaveBeenCalledWith('https://example.com', { forceOpenInBrowser: true })
+  })
+})

package/src/utils/native_adapters/linking.ts

@@ -1,10 +1,19 @@
 import { Linking } from 'react-native'
 
-export class LinkingAdapter {
-  openURL: Linking['openURL']
+export type LinkingOpenURLOptions = {
+  forceOpenInBrowser?: boolean
+}
+
+type LinkingMethods = {
+  openURL: (url: string, options?: LinkingOpenURLOptions) => Promise<unknown>
   canOpenURL: Linking['canOpenURL']
+}
+
+export class LinkingAdapter {
+  openURL: LinkingMethods['openURL']
+  canOpenURL: LinkingMethods['canOpenURL']
 
-  constructor(methods: Pick<Linking, 'openURL' | 'canOpenURL'>) {
+  constructor(methods: LinkingMethods) {
     this.openURL = methods.openURL.bind(Linking)
     this.canOpenURL = methods.canOpenURL.bind(Linking)
   }

package/src/utils/response_error.ts

@@ -39,10 +39,10 @@ export const isResponseLike = (value: unknown): value is Response => {
   )
 }
 
-export const throwResponseError = (error: unknown) => {
+export const throwResponseError = (error: unknown): never => {
   if (isResponseLike(error)) {
     throw new ResponseError(error as FailedResponse)
   }
 
-  return Promise.reject(error)
+  throw error
 }