feat: rename MockProvider to CustomProvider and expose it (#8)

feat: rename MockProvider to CustomProvider and expose it

Author: varl

runtime/src/index.js

@@ -1,4 +1,5 @@
 export {
+    CustomProvider as CustomDataProvider,
     Provider as DataProvider,
     Query as DataQuery,
     useQuery as useDataQuery,

services/data/src/__tests__/integration.test.tsx

@@ -1,15 +1,15 @@
 import React from 'react'
 import { useQuery } from '..'
 import { render, waitForElement } from 'react-testing-library'
-import { MockProvider } from '../components/MockProvider'
+import { CustomProvider } from '../components/CustomProvider'
 import { Query } from '../components/Query'
 import { QueryRenderInput } from '../types/Query'
 
-const mockData = {
+const customData = {
     answer: 42,
 }
 
-describe('Testing mock data provider and useQuery hook', () => {
+describe('Testing custom data provider and useQuery hook', () => {
     it('Should render without failing', async () => {
         const renderFunction = jest.fn(
             ({ loading, error, data }: QueryRenderInput) => {
@@ -20,11 +20,11 @@ describe('Testing mock data provider and useQuery hook', () => {
         )
 
         const { getByText } = render(
-            <MockProvider mockData={mockData}>
+            <CustomProvider data={customData}>
                 <Query query={{ answer: { resource: 'answer' } }}>
                     {renderFunction}
                 </Query>
-            </MockProvider>
+            </CustomProvider>
         )
 
         expect(getByText(/loading/i)).not.toBeUndefined()
@@ -36,15 +36,15 @@ describe('Testing mock data provider and useQuery hook', () => {
         expect(renderFunction).toHaveBeenCalledTimes(2)
         expect(renderFunction).toHaveBeenLastCalledWith({
             loading: false,
-            data: mockData,
+            data: customData,
         })
         expect(getByText(/data: /i)).toHaveTextContent(
-            `data: ${mockData.answer}`
+            `data: ${customData.answer}`
         )
     })
 })
 
-describe('Testing mock data provider and useQuery hook', () => {
+describe('Testing custom data provider and useQuery hook', () => {
     it('Should render an error', async () => {
         const renderFunction = jest.fn(
             ({ loading, error, data }: QueryRenderInput) => {
@@ -55,11 +55,11 @@ describe('Testing mock data provider and useQuery hook', () => {
         )
 
         const { getByText } = render(
-            <MockProvider mockData={mockData}>
+            <CustomProvider data={customData}>
                 <Query query={{ test: { resource: 'test' } }}>
                     {renderFunction}
                 </Query>
-            </MockProvider>
+            </CustomProvider>
         )
 
         expect(getByText(/loading/i)).not.toBeUndefined()
@@ -70,10 +70,10 @@ describe('Testing mock data provider and useQuery hook', () => {
         await waitForElement(() => getByText(/error: /i))
         expect(renderFunction).toHaveBeenCalledTimes(2)
         expect(String(renderFunction.mock.calls[1][0].error)).toBe(
-            'Error: No mock provided for resource type test!'
+            'Error: No data provided for resource type test!'
         )
         // expect(getByText(/data: /i)).toHaveTextContent(
-        //     `data: ${mockData.answer}`
+        //     `data: ${customData.answer}`
         // )
     })
 })

services/data/src/components/CustomProvider.tsx

@@ -0,0 +1,21 @@
+import React from 'react'
+import {
+    makeCustomContext,
+    CustomContextData,
+    CustomContextOptions,
+} from '../context/makeCustomContext'
+import { Context } from './Context'
+
+interface CustomProviderInput {
+    children: React.ReactNode
+    data: CustomContextData
+    options?: CustomContextOptions
+}
+export const CustomProvider = ({
+    children,
+    data,
+    options,
+}: CustomProviderInput) => {
+    const context = makeCustomContext(data, options)
+    return <Context.Provider value={context}>{children}</Context.Provider>
+}

services/data/src/components/MockProvider.tsx

@@ -1,53 +1,61 @@
-import { makeMockContext } from './makeMockContext'
+import { makeCustomContext } from './makeCustomContext'
 import { QueryDefinition } from '../types/Query'
 import { bigIntLiteral } from '@babel/types'
 
-describe('makeMockContext', () => {
-    it('Should throw if requested resource is not mocked', () => {
-        const context = makeMockContext({})
+describe('makeCustomContext', () => {
+    it('Should throw if requested custom resource is not provided', () => {
+        const context = makeCustomContext({})
         expect(context.fetch({ resource: 'test' })).rejects.toBeTruthy()
     })
     it('Should return empty object on miss if failOnMiss=false', async () => {
-        const context = makeMockContext({}, { failOnMiss: false })
+        const context = makeCustomContext({}, { failOnMiss: false })
         expect(await context.fetch({ resource: 'test' })).toEqual({})
     })
-    it('Should return mocked resources', async () => {
-        const mockData = {
+    it('Should return custom resources', async () => {
+        const customData = {
             test: { value: 'something' },
             user: { id: 42 },
         }
-        const context = makeMockContext(mockData)
-        expect(await context.fetch({ resource: 'test' })).toEqual(mockData.test)
-        expect(await context.fetch({ resource: 'user' })).toEqual(mockData.user)
+        const context = makeCustomContext(customData)
+        expect(await context.fetch({ resource: 'test' })).toEqual(
+            customData.test
+        )
+        expect(await context.fetch({ resource: 'user' })).toEqual(
+            customData.user
+        )
     })
-    it('Should resolve mocked resource with function', async () => {
-        const mockData = {
+    it('Should resolve custom resource with function', async () => {
+        const customData = {
             test: { value: 'something' },
             user: { id: 42 },
         }
-        const context = makeMockContext(mockData)
-        expect(await context.fetch({ resource: 'test' })).toEqual(mockData.test)
-        expect(await context.fetch({ resource: 'user' })).toEqual(mockData.user)
+        const context = makeCustomContext(customData)
+        expect(await context.fetch({ resource: 'test' })).toEqual(
+            customData.test
+        )
+        expect(await context.fetch({ resource: 'user' })).toEqual(
+            customData.user
+        )
     })
     it('Should throw if resolver returns undefined', async () => {
-        const mockData = {
+        const customData = {
             test: () => undefined,
         }
-        const context = makeMockContext(mockData)
+        const context = makeCustomContext(customData)
         expect(context.fetch({ resource: 'test' })).rejects.toBeTruthy()
     })
     it('Should not throw if resolver returns undefined with failOnMiss=false', async () => {
-        const mockData = {
+        const customData = {
             test: () => undefined,
         }
-        const context = makeMockContext(mockData, { failOnMiss: false })
+        const context = makeCustomContext(customData, { failOnMiss: false })
         expect(context.fetch({ resource: 'test' })).resolves.toEqual({})
     })
-    it('Should throw if mock is something crazy like a bigint', async () => {
-        const mockData = {
+    it('Should throw if custom data is something crazy like a bigint', async () => {
+        const customData = {
             test: null as any,
         }
-        const context = makeMockContext(mockData, { failOnMiss: false })
+        const context = makeCustomContext(customData, { failOnMiss: false })
         expect(context.fetch({ resource: 'test' })).resolves.toEqual({})
     })
 })

services/data/src/context/makeMockContext.test.ts renamed to services/data/src/context/makeCustomContext.test.ts

@@ -7,74 +7,76 @@ import { FetchErrorPayload } from '../types/FetchError'
 const baseUrl = 'https://example.com'
 const apiVersion = 42
 
-export type MockResourceLiteral =
+export type CustomResourceLiteral =
     | string
     | number
     | boolean
     | object
     | FetchErrorPayload
-export type MockResourceFactory = (
+export type CustomResourceFactory = (
     query: QueryDefinition
-) => Promise<MockResourceLiteral>
-export type MockResource = MockResourceLiteral | MockResourceFactory
-export interface MockContextData {
-    [resourceName: string]: MockResource
+) => Promise<CustomResourceLiteral>
+export type CustomResource = CustomResourceLiteral | CustomResourceFactory
+export interface CustomContextData {
+    [resourceName: string]: CustomResource
 }
-export type MockContextOptions = {
+export type CustomContextOptions = {
     failOnMiss?: boolean
 }
 
-const resolveMock = async (
-    mockResource: MockResource,
+const resolveCustomResource = async (
+    customResource: CustomResource,
     query: QueryDefinition,
-    { failOnMiss }: MockContextOptions
-): Promise<MockResource> => {
-    switch (typeof mockResource) {
+    { failOnMiss }: CustomContextOptions
+): Promise<CustomResource> => {
+    switch (typeof customResource) {
         case 'string':
         case 'number':
         case 'boolean':
         case 'object':
-            return mockResource
+            return customResource
         case 'function':
             // function
-            const result = await mockResource(query)
+            const result = await customResource(query)
             if (!result && failOnMiss) {
                 throw new Error(
-                    `The mock function for resource ${
+                    `The custom function for resource ${
                         query.resource
                     } must always return a value but returned ${result}`
                 )
             }
             return result || {}
         default:
             // should be unreachable
-            throw new Error(`Unknown mock type ${typeof mockResource}`)
+            throw new Error(`Unknown resource type ${typeof customResource}`)
     }
 }
 
-export const makeMockContext = (
-    mockData: MockContextData,
-    { failOnMiss = true }: MockContextOptions = {}
+export const makeCustomContext = (
+    customData: CustomContextData,
+    { failOnMiss = true }: CustomContextOptions = {}
 ): ContextType => {
     const apiUrl = joinPath(baseUrl, 'api', String(apiVersion))
-    const mockFetch: FetchFunction = async query => {
-        const mockResource = mockData[query.resource]
-        if (!mockResource) {
+    const customFetch: FetchFunction = async query => {
+        const customResource = customData[query.resource]
+        if (!customResource) {
             if (failOnMiss) {
                 throw new Error(
-                    `No mock provided for resource type ${query.resource}!`
+                    `No data provided for resource type ${query.resource}!`
                 )
             }
             return Promise.resolve({})
         }
 
-        return await resolveMock(mockResource, query, { failOnMiss })
+        return await resolveCustomResource(customResource, query, {
+            failOnMiss,
+        })
     }
     const context = {
         baseUrl,
         apiVersion,
         apiUrl,
-        fetch: mockFetch,
+        fetch: customFetch,
     }
     return context
 }

services/data/src/context/makeMockContext.ts renamed to services/data/src/context/makeCustomContext.ts

@@ -1,5 +1,5 @@
 export { Query } from './components/Query'
 export { Provider } from './components/Provider'
-export { MockProvider } from './components/MockProvider'
+export { CustomProvider } from './components/CustomProvider'
 export { Context } from './components/Context'
 export { useQuery } from './hooks/useQuery'