chore: update tests for caching and localizing routes

Author: orinokai

packages/runtime/src/templates/handlerUtils.test.ts

@@ -1,41 +1,82 @@
-import { removeTrailingSlash, ensureLocalePrefix } from './handlerUtils'
+import { normalizeRoute, unlocalizeRoute, localizeRoute, localizeDataRoute } from './handlerUtils'
 
-describe('removeTrailingSlash', () => {
-  it('removes a trailing slash from a string', () => {
-    expect(removeTrailingSlash('/foo/')).toEqual('/foo')
+describe('normalizeRoute', () => {
+  it('removes a trailing slash from a route', () => {
+    expect(normalizeRoute('/foo/')).toEqual('/foo')
   })
   it('ignores a string without a trailing slash', () => {
-    expect(removeTrailingSlash('/foo')).toEqual('/foo')
+    expect(normalizeRoute('/foo')).toEqual('/foo')
   })
-  it('does not remove a slash on its own', () => {
-    expect(removeTrailingSlash('/')).toEqual('/')
+  it('does not remove a lone slash', () => {
+    expect(normalizeRoute('/')).toEqual('/')
   })
 })
 
-describe('ensureLocalePrefix', () => {
-  it('adds default locale prefix if missing', () => {
+describe('unlocalizeRoute', () => {
+  it('removes the locale prefix from an i18n route', () => {
     expect(
-      ensureLocalePrefix('/foo', {
+      unlocalizeRoute('/fr/foo', {
+        defaultLocale: 'en',
+        locales: ['en', 'fr', 'de'],
+      }),
+    ).toEqual('/foo')
+  })
+  it('removes the locale prefix from a root i18n route', () => {
+    expect(
+      unlocalizeRoute('/de', {
+        defaultLocale: 'en',
+        locales: ['en', 'fr', 'de'],
+      }),
+    ).toEqual('/')
+  })
+  it('does not modify a default locale route', () => {
+    expect(
+      unlocalizeRoute('/foo', {
+        defaultLocale: 'en',
+        locales: ['en', 'fr', 'de'],
+      }),
+    ).toEqual('/foo')
+  })
+})
+
+describe('localizeRoute', () => {
+  it('adds the locale prefix to an i18n route', () => {
+    expect(
+      localizeRoute('/foo', {
         defaultLocale: 'en',
         locales: ['en', 'fr', 'de'],
       }),
     ).toEqual('/en/foo')
   })
-  it('skips prefixing if locale is present', () => {
+  it('adds the locale prefix to a root i18n route', () => {
     expect(
-      ensureLocalePrefix('/fr/foo', {
+      localizeRoute('/', {
         defaultLocale: 'en',
         locales: ['en', 'fr', 'de'],
       }),
-    ).toEqual('/fr/foo')
+    ).toEqual('/en')
+  })
+  it('does not modify a prefixed i18n route', () => {
     expect(
-      ensureLocalePrefix('/en/foo', {
+      localizeRoute('/en/foo', {
         defaultLocale: 'en',
         locales: ['en', 'fr', 'de'],
       }),
     ).toEqual('/en/foo')
   })
-  it('skips localization if i18n not configured', () => {
-    expect(ensureLocalePrefix('/foo')).toEqual('/foo')
+})
+
+describe('localizeDataRoute', () => {
+  it('adds the locale prefix to a data route', () => {
+    expect(localizeDataRoute('/_next/data/build/foo.json', '/en/foo')).toEqual('/_next/data/build/en/foo.json')
+  })
+  it('removes the index suffix from a root route', () => {
+    expect(localizeDataRoute('/_next/data/build/index.json', '/en')).toEqual('/_next/data/build/en.json')
+  })
+  it('does not add the locale prefix if it already exists in the data route', () => {
+    expect(localizeDataRoute('/_next/data/build/en/foo.json', '/en/foo')).toEqual('/_next/data/build/en/foo.json')
+  })
+  it('does not modify an RSC data route', () => {
+    expect(localizeDataRoute('/foo.rsc', '/foo')).toEqual('/foo.rsc')
   })
 })

packages/runtime/src/templates/server.test.ts

@@ -1,7 +1,9 @@
+/* eslint-disable max-lines-per-function */
 import { mockRequest } from 'next/dist/server/lib/mock-request'
+import { Options } from 'next/dist/server/next-server'
 
 import { getNextServer, NextServerType, netlifyApiFetch } from './handlerUtils'
-import { NetlifyNextServer } from './server'
+import { NetlifyNextServer, NetlifyConfig } from './server'
 
 jest.mock('./handlerUtils', () => {
   const originalModule = jest.requireActual('./handlerUtils')
@@ -14,15 +16,35 @@ jest.mock('./handlerUtils', () => {
 })
 const mockedApiFetch = netlifyApiFetch as jest.MockedFunction<typeof netlifyApiFetch>
 
+const mocki18nConfig = {
+  i18n: {
+    defaultLocale: 'en',
+    locales: ['en', 'fr', 'de'],
+  },
+}
+
+const mockTokenConfig = {
+  revalidateToken: 'test',
+}
+
+const mockBuildId = 'build-id'
+
 jest.mock(
   'prerender-manifest.json',
   () => ({
     routes: {
-      '/en/getStaticProps/with-revalidate': {
-        dataRoute: '/_next/data/en/getStaticProps/with-revalidate.json',
+      '/non-i18n/with-revalidate': {
+        dataRoute: `/_next/data/${mockBuildId}/non-i18n/with-revalidate.json`,
+      },
+      '/en/i18n/with-revalidate': {
+        dataRoute: `/_next/data/${mockBuildId}/i18n/with-revalidate.json`,
       },
     },
     dynamicRoutes: {
+      '/posts/[title]': {
+        routeRegex: '^/posts/([^/]+?)(?:/)?$',
+        dataRoute: `/_next/data/${mockBuildId}/posts/[title].json`,
+      },
       '/blog/[author]/[slug]': {
         routeRegex: '^/blog/([^/]+?)/([^/]+?)(?:/)?$',
         dataRoute: '/blog/[author]/[slug].rsc',
@@ -36,41 +58,52 @@ beforeAll(() => {
   const NextServer: NextServerType = getNextServer()
   jest.spyOn(NextServer.prototype, 'getRequestHandler').mockImplementation(() => () => Promise.resolve())
 
-  const MockNetlifyNextServerConstructor = function () {
+  const MockNetlifyNextServerConstructor = function (nextOptions: Options, netlifyConfig: NetlifyConfig) {
     this.distDir = '.'
-    this.buildId = 'build-id'
-    this.nextConfig = {
-      i18n: {
-        defaultLocale: 'en',
-        locales: ['en', 'fr', 'de'],
-      },
-    }
+    this.buildId = mockBuildId
+    this.nextConfig = nextOptions.conf
+    this.netlifyConfig = netlifyConfig
   }
   Object.setPrototypeOf(NetlifyNextServer, MockNetlifyNextServerConstructor)
 })
 
 describe('the netlify next server', () => {
-  it('revalidates a request containing an `x-prerender-revalidate` header', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+  it('does not revalidate a request without an `x-prerender-revalidate` header', async () => {
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, { ...mockTokenConfig })
+    const requestHandler = netlifyNextServer.getRequestHandler()
+
+    const { req: mockReq, res: mockRes } = mockRequest('/getStaticProps/with-revalidate/', {}, 'GET')
+    await requestHandler(mockReq, mockRes)
+
+    expect(mockedApiFetch).not.toHaveBeenCalled()
+  })
+
+  it('revalidates a static non-i18n route with an `x-prerender-revalidate` header', async () => {
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, { ...mockTokenConfig })
     const requestHandler = netlifyNextServer.getRequestHandler()
 
     const { req: mockReq, res: mockRes } = mockRequest(
-      '/getStaticProps/with-revalidate/',
+      '/non-i18n/with-revalidate/',
       { 'x-prerender-revalidate': 'test' },
       'GET',
     )
-    const response = await requestHandler(mockReq, mockRes)
+    await requestHandler(mockReq, mockRes)
 
-    expect(mockedApiFetch).toHaveBeenCalled()
-    expect(response).toBe(undefined)
+    expect(mockedApiFetch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          paths: ['/non-i18n/with-revalidate/', `/_next/data/${mockBuildId}/non-i18n/with-revalidate.json`],
+        }),
+      }),
+    )
   })
 
-  it('matches a normalized static route to find the data route', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+  it('revalidates a static i18n route with an `x-prerender-revalidate` header', async () => {
+    const netlifyNextServer = new NetlifyNextServer({ conf: { ...mocki18nConfig } }, { ...mockTokenConfig })
     const requestHandler = netlifyNextServer.getRequestHandler()
 
     const { req: mockReq, res: mockRes } = mockRequest(
-      '/getStaticProps/with-revalidate/',
+      '/i18n/with-revalidate/',
       { 'x-prerender-revalidate': 'test' },
       'GET',
     )
@@ -79,14 +112,14 @@ describe('the netlify next server', () => {
     expect(mockedApiFetch).toHaveBeenCalledWith(
       expect.objectContaining({
         payload: expect.objectContaining({
-          paths: ['/getStaticProps/with-revalidate/', '/_next/data/build-id/en/getStaticProps/with-revalidate.json'],
+          paths: ['/i18n/with-revalidate/', `/_next/data/${mockBuildId}/en/i18n/with-revalidate.json`],
         }),
       }),
     )
   })
 
-  it('matches a normalized dynamic route to find the data', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+  it('revalidates a dynamic non-i18n route with an `x-prerender-revalidate` header', async () => {
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, { ...mockTokenConfig })
     const requestHandler = netlifyNextServer.getRequestHandler()
 
     const { req: mockReq, res: mockRes } = mockRequest('/blog/rob/hello', { 'x-prerender-revalidate': 'test' }, 'GET')
@@ -101,8 +134,24 @@ describe('the netlify next server', () => {
     )
   })
 
+  it('revalidates a dynamic i18n route with an `x-prerender-revalidate` header', async () => {
+    const netlifyNextServer = new NetlifyNextServer({ conf: { ...mocki18nConfig } }, { ...mockTokenConfig })
+    const requestHandler = netlifyNextServer.getRequestHandler()
+
+    const { req: mockReq, res: mockRes } = mockRequest('/fr/posts/hello', { 'x-prerender-revalidate': 'test' }, 'GET')
+    await requestHandler(mockReq, mockRes)
+
+    expect(mockedApiFetch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          paths: ['/fr/posts/hello', `/_next/data/${mockBuildId}/fr/posts/hello.json`],
+        }),
+      }),
+    )
+  })
+
   it('throws an error when route is not found in the manifest', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, mockTokenConfig)
     const requestHandler = netlifyNextServer.getRequestHandler()
 
     const { req: mockReq, res: mockRes } = mockRequest(
@@ -111,34 +160,27 @@ describe('the netlify next server', () => {
       'GET',
     )
 
-    await expect(requestHandler(mockReq, mockRes)).rejects.toThrow('could not find a route')
+    await expect(requestHandler(mockReq, mockRes)).rejects.toThrow('not an ISR route')
   })
 
   it('throws an error when paths are not found by the API', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, mockTokenConfig)
     const requestHandler = netlifyNextServer.getRequestHandler()
 
-    const { req: mockReq, res: mockRes } = mockRequest(
-      '/getStaticProps/with-revalidate/',
-      { 'x-prerender-revalidate': 'test' },
-      'GET',
-    )
+    const { req: mockReq, res: mockRes } = mockRequest('/posts/hello/', { 'x-prerender-revalidate': 'test' }, 'GET')
 
     mockedApiFetch.mockResolvedValueOnce({ code: 500, message: 'Failed to revalidate' })
     await expect(requestHandler(mockReq, mockRes)).rejects.toThrow('Failed to revalidate')
   })
 
   it('throws an error when the revalidate API is unreachable', async () => {
-    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, {})
+    const netlifyNextServer = new NetlifyNextServer({ conf: {} }, mockTokenConfig)
     const requestHandler = netlifyNextServer.getRequestHandler()
 
-    const { req: mockReq, res: mockRes } = mockRequest(
-      '/getStaticProps/with-revalidate/',
-      { 'x-prerender-revalidate': 'test' },
-      'GET',
-    )
+    const { req: mockReq, res: mockRes } = mockRequest('/posts/hello', { 'x-prerender-revalidate': 'test' }, 'GET')
 
     mockedApiFetch.mockRejectedValueOnce(new Error('Unable to connect'))
     await expect(requestHandler(mockReq, mockRes)).rejects.toThrow('Unable to connect')
   })
 })
+/* eslint-enable max-lines-per-function */