@jasonshimmy/vite-plugin-cer-app 0.23.2 → 0.24.0

package/e2e/cypress/e2e/per-route-render.cy.ts

@@ -1,70 +0,0 @@
-/**
- * Tests for per-route render strategy (meta.render).
- *
- * render: 'server' — route is always SSR'd, skipped during SSG pre-rendering.
- * render: 'spa'    — route is served as SPA shell in SSR mode, skipped in SSG.
- * render: 'static' — serve pre-rendered HTML from disk; fall back to SSR.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-// ─── render: 'server' ─────────────────────────────────────────────────────────
-
-describe('render: server — always SSR', () => {
-  it('renders the page in SSR mode', () => {
-    if (mode !== 'ssr') return
-    cy.visit('/render-server-test')
-    cy.get('[data-cy=render-server-heading]').should('contain', 'Render Server Test')
-  })
-
-  it('renders the page in SPA mode (client-side navigation)', () => {
-    if (mode !== 'spa') return
-    cy.visit('/render-server-test')
-    cy.get('[data-cy=render-server-heading]').should('contain', 'Render Server Test')
-  })
-
-  if (mode === 'ssr') {
-    it('pre-renders the page in the initial HTML (SSR)', () => {
-      cy.request('/render-server-test').then((response) => {
-        expect(response.body).to.include('render-server-heading')
-        expect(response.body).to.include('Render Server Test')
-      })
-    })
-  }
-
-  if (mode === 'ssg') {
-    it('route with render:server is not pre-rendered — not found in ssg dist', () => {
-      // The route was skipped during SSG. The static preview falls back to
-      // dist/index.html (SPA shell) rather than a pre-rendered page, so the
-      // server-rendered heading is absent from the raw HTML response.
-      cy.request('/render-server-test').then((response) => {
-        expect(response.body).not.to.include('render-server-heading')
-      })
-    })
-  }
-})
-
-// ─── render: 'spa' ────────────────────────────────────────────────────────────
-
-describe('render: spa — client-only', () => {
-  it('renders the page heading after JS boots', () => {
-    cy.visit('/render-spa-test')
-    cy.get('[data-cy=render-spa-heading]').should('contain', 'Render SPA Test')
-  })
-
-  if (mode === 'ssr') {
-    it('raw HTML response is the SPA shell (no SSR content)', () => {
-      cy.request('/render-spa-test').then((response) => {
-        expect(response.body).not.to.include('render-spa-heading')
-      })
-    })
-  }
-
-  if (mode === 'ssg') {
-    it('route with render:spa is not pre-rendered — not found in ssg dist', () => {
-      cy.request('/render-spa-test').then((response) => {
-        expect(response.body).not.to.include('render-spa-heading')
-      })
-    })
-  }
-})

package/e2e/cypress/e2e/preview-hardening.cy.ts

@@ -1,88 +0,0 @@
-/**
- * Preview server hardening e2e tests — verifies security headers,
- * Cache-Control values, and graceful shutdown behaviour.
- *
- * Security headers and Cache-Control are server-level concerns, so these
- * tests only run in SSR and SSG modes (both use `cer-app preview`).
- * SPA mode also runs through the preview server, so the tests apply there too.
- * Dev mode uses the Vite dev server which does not set these headers.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg' | 'dev'
-
-// Security headers and Cache-Control are only set by the production preview server.
-// Skip these tests in dev mode (Vite dev server does not set them).
-if (mode !== 'dev') {
-  describe('Preview server — security headers', () => {
-    it('responds with X-Content-Type-Options: nosniff', () => {
-      cy.request('/').then((response) => {
-        expect(response.headers['x-content-type-options']).to.eq('nosniff')
-      })
-    })
-
-    it('responds with X-Frame-Options: DENY', () => {
-      cy.request('/').then((response) => {
-        expect(response.headers['x-frame-options']).to.eq('DENY')
-      })
-    })
-
-    it('responds with Referrer-Policy: strict-origin-when-cross-origin', () => {
-      cy.request('/').then((response) => {
-        expect(response.headers['referrer-policy']).to.eq('strict-origin-when-cross-origin')
-      })
-    })
-
-    it('includes security headers on 404 responses', () => {
-      cy.request({ url: '/definitely-not-a-real-page-xyz', failOnStatusCode: false }).then((response) => {
-        expect(response.headers['x-content-type-options']).to.eq('nosniff')
-      })
-    })
-  })
-}
-
-describe('Preview server — path traversal protection', () => {
-  // HTTP clients (including Cypress/got) normalize `..` segments before sending,
-  // so a raw traversal like `/../../../../etc/passwd` arrives at the server as
-  // `/etc/passwd`. The `isPathBounded` guard is exercised via unit tests
-  // (src/__tests__/cli/preview-isr.test.ts). Here we verify the observable
-  // guarantee: files that do not exist inside dist/ are never served.
-  it('does not serve a file that does not exist inside dist/', () => {
-    cy.request({ url: '/etc/passwd', failOnStatusCode: false }).then((response) => {
-      // Either 404 (static) or 200 (SSR SPA fallback) — never a served file from
-      // outside the dist directory. Critically, the response body must NOT contain
-      // typical /etc/passwd content.
-      expect(response.body).not.to.include('root:x:')
-      expect(response.body).not.to.include('/bin/bash')
-    })
-  })
-
-  // NOTE: HTTP clients (including Cypress/got) normalize `..` segments before
-  // sending, so raw traversal sequences never arrive at the server unchanged.
-  // The isPathBounded() guard is exhaustively covered at the unit level in
-  // src/__tests__/cli/preview-isr.test.ts. No additional e2e assertion is needed.
-})
-
-if (mode !== 'dev') {
-  describe('Preview server — Cache-Control', () => {
-    it('serves HTML with Cache-Control: no-cache', () => {
-      cy.request('/').then((response) => {
-        expect(response.headers['cache-control']).to.include('no-cache')
-      })
-    })
-
-    it('serves content-hashed assets with immutable Cache-Control', () => {
-      // Get the page to discover an actual asset URL (Vite hashes asset filenames)
-      cy.request('/').then((htmlResponse) => {
-        const assetMatch = htmlResponse.body.match(/\/assets\/[^"'\s]+\.js/)
-        if (!assetMatch) return  // no JS asset found in this page, skip
-
-        const assetUrl = assetMatch[0]
-        cy.request(assetUrl).then((assetResponse) => {
-          const cc = assetResponse.headers['cache-control'] as string
-          expect(cc).to.include('max-age=31536000')
-          expect(cc).to.include('immutable')
-        })
-      })
-    })
-  })
-}

package/e2e/cypress/e2e/routes.cy.ts

@@ -1,128 +0,0 @@
-/**
- * Routes test — verifies every route renders correct content in all build modes.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-describe('Route rendering', () => {
-  context('Home page (/)', () => {
-    it('renders the home heading', () => {
-      cy.visit('/')
-      cy.get('[data-cy=home-heading]').should('contain', 'Kitchen Sink')
-    })
-
-    it('renders the ks-badge component', () => {
-      cy.visit('/')
-      cy.get('[data-cy=ks-badge]').should('exist')
-    })
-
-    it('renders the default layout with nav', () => {
-      cy.visit('/')
-      cy.get('[data-cy=site-nav]').should('exist')
-      cy.get('[data-cy=site-header]').should('exist')
-      cy.get('[data-cy=site-footer]').should('exist')
-    })
-
-    it('renders all nav links', () => {
-      cy.visit('/')
-      cy.get('[data-cy=nav-home]').should('exist')
-      cy.get('[data-cy=nav-about]').should('exist')
-      cy.get('[data-cy=nav-counter]').should('exist')
-      cy.get('[data-cy=nav-blog]').should('exist')
-    })
-  })
-
-  context('About page (/about) — minimal layout + useHead', () => {
-    it('renders the about heading', () => {
-      cy.visit('/about')
-      cy.get('[data-cy=about-heading]').should('contain', 'About')
-    })
-
-    it('uses the minimal layout (no site-nav)', () => {
-      cy.visit('/about')
-      cy.get('[data-cy=minimal-layout]').should('exist')
-      cy.get('[data-cy=site-nav]').should('not.exist')
-    })
-  })
-
-  context('Counter page (/counter)', () => {
-    it('renders the counter heading', () => {
-      cy.visit('/counter')
-      cy.get('[data-cy=counter-heading]').should('contain', 'Counter')
-    })
-
-    it('renders the counter widget with initial count of 0', () => {
-      cy.visit('/counter')
-      cy.get('[data-cy=count]').should('contain', '0')
-    })
-
-    it('renders increment, decrement, and reset buttons', () => {
-      cy.visit('/counter')
-      cy.get('[data-cy=increment]').should('exist')
-      cy.get('[data-cy=decrement]').should('exist')
-      cy.get('[data-cy=reset]').should('exist')
-    })
-  })
-
-  context('Head page (/head) — useHead', () => {
-    it('renders the head-test heading', () => {
-      cy.visit('/head')
-      cy.get('[data-cy=head-heading]').should('contain', 'Head Test')
-    })
-  })
-
-  context('Blog list page (/blog)', () => {
-    it('renders the blog heading', () => {
-      cy.visit('/blog')
-      cy.get('[data-cy=blog-heading]').should('contain', 'Blog')
-    })
-  })
-
-  context('Blog detail page (/blog/first-post) — dynamic route', () => {
-    it('renders the post title', () => {
-      cy.visit('/blog/first-post')
-      cy.get('[data-cy=post-title]').should('contain', 'First Post')
-    })
-
-    it('renders the post slug', () => {
-      cy.visit('/blog/first-post')
-      cy.get('[data-cy=post-slug]').should('contain', 'first-post')
-    })
-  })
-
-  context('Item page (/items/1) — route params via useProps', () => {
-    it('renders the item heading', () => {
-      cy.visit('/items/1')
-      cy.get('[data-cy=item-heading]').should('contain', 'Item Detail')
-    })
-
-    it('shows the correct item ID from route params', () => {
-      cy.visit('/items/1')
-      cy.get('[data-cy=item-id]').should('contain', '1')
-    })
-
-    it('shows a different ID for /items/2', () => {
-      cy.visit('/items/2')
-      cy.get('[data-cy=item-id]').should('contain', '2')
-    })
-  })
-
-  context('Login page (/login) — route group, minimal layout', () => {
-    it('renders the login heading', () => {
-      cy.visit('/login')
-      cy.get('[data-cy=login-heading]').should('contain', 'Login')
-    })
-
-    it('uses the minimal layout', () => {
-      cy.visit('/login')
-      cy.get('[data-cy=minimal-layout]').should('exist')
-    })
-  })
-
-  context('404 page — catch-all route', () => {
-    it('renders the 404 heading for an unknown path', () => {
-      cy.visit('/this-page-does-not-exist-at-all', { failOnStatusCode: false })
-      cy.get('[data-cy=not-found-heading]').should('contain', '404')
-    })
-  })
-})

package/e2e/cypress/e2e/seo-meta.cy.ts

@@ -1,108 +0,0 @@
-/**
- * useSeoMeta() e2e tests — verifies Open Graph, Twitter Card, canonical, and
- * title/description tags are injected correctly in all modes.
- *
- * In SSR/SSG: tags must be present in the initial server-rendered HTML.
- * In all modes: tags must be present after client hydration.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-describe('useSeoMeta() — title and description', () => {
-  it('sets document title', () => {
-    cy.visit('/seo-test')
-    cy.title().should('eq', 'SEO Test — Kitchen Sink')
-  })
-
-  it('sets meta description', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[name="description"]').should('have.attr', 'content', 'A test page for useSeoMeta().')
-  })
-})
-
-describe('useSeoMeta() — Open Graph tags', () => {
-  it('sets og:title', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:title"]').should('have.attr', 'content', 'SEO Test OG Title')
-  })
-
-  it('sets og:description', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:description"]').should('have.attr', 'content', 'SEO Test OG description.')
-  })
-
-  it('sets og:image', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:image"]').should('have.attr', 'content', 'https://example.com/og/seo-test.png')
-  })
-
-  it('sets og:url', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:url"]').should('have.attr', 'content', 'https://example.com/seo-test')
-  })
-
-  it('sets og:type', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:type"]').should('have.attr', 'content', 'website')
-  })
-
-  it('sets og:site_name', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[property="og:site_name"]').should('have.attr', 'content', 'Kitchen Sink')
-  })
-})
-
-describe('useSeoMeta() — Twitter Card tags', () => {
-  it('sets twitter:card', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[name="twitter:card"]').should('have.attr', 'content', 'summary_large_image')
-  })
-
-  it('sets twitter:title', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[name="twitter:title"]').should('have.attr', 'content', 'SEO Test Twitter Title')
-  })
-
-  it('sets twitter:site', () => {
-    cy.visit('/seo-test')
-    cy.get('meta[name="twitter:site"]').should('have.attr', 'content', '@ks')
-  })
-})
-
-describe('useSeoMeta() — canonical link', () => {
-  it('sets canonical link element', () => {
-    cy.visit('/seo-test')
-    cy.get('link[rel="canonical"]').should('have.attr', 'href', 'https://example.com/seo-test')
-  })
-})
-
-if (mode !== 'spa') {
-  describe('useSeoMeta() — server-side injection (SSR/SSG)', () => {
-    it('title is in the initial HTML', () => {
-      cy.request('/seo-test').then((response) => {
-        expect(response.body).to.include('<title>SEO Test — Kitchen Sink</title>')
-      })
-    })
-
-    it('og:title meta is in the initial HTML', () => {
-      cy.request('/seo-test').then((response) => {
-        expect(response.body).to.include('og:title')
-        expect(response.body).to.include('SEO Test OG Title')
-      })
-    })
-
-    it('twitter:card meta is in the initial HTML', () => {
-      cy.request('/seo-test').then((response) => {
-        expect(response.body).to.include('twitter:card')
-        expect(response.body).to.include('summary_large_image')
-      })
-    })
-
-    it('canonical link is in the initial HTML', () => {
-      cy.request('/seo-test').then((response) => {
-        expect(response.body).to.include('canonical')
-        expect(response.body).to.include('https://example.com/seo-test')
-      })
-    })
-  })
-}

package/e2e/cypress/e2e/server-middleware.cy.ts

@@ -1,46 +0,0 @@
-/**
- * Server middleware e2e tests — verifies that files in server/middleware/ run
- * on every HTTP request before API routes and SSR rendering.
- *
- * The kitchen-sink includes `server/middleware/01-headers.ts` which sets
- * `X-CER-Middleware: active` on every response. These tests confirm that
- * header is present, proving the middleware chain executed.
- *
- * Server middleware runs in SSR mode (production) and dev mode. It does NOT
- * run in SPA or SSG static-file serving modes, so tests are gated accordingly.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-// Server middleware only runs when there is a live server processing requests.
-// In dev mode the Vite middleware chain applies it; in SSR preview it is called
-// by runServerMiddleware(). SPA and SSG preview servers serve static files and
-// do not execute server middleware.
-if (mode === 'ssr') {
-  describe('Server middleware — header injection (SSR)', () => {
-    it('adds X-CER-Middleware header to HTML responses', () => {
-      cy.request('/').then((response) => {
-        expect(response.headers['x-cer-middleware']).to.eq('active')
-      })
-    })
-
-    it('adds X-CER-Middleware header to API responses', () => {
-      cy.request('/api/health').then((response) => {
-        expect(response.headers['x-cer-middleware']).to.eq('active')
-      })
-    })
-
-    it('adds X-CER-Middleware header to 404 responses', () => {
-      cy.request({ url: '/this-path-does-not-exist', failOnStatusCode: false }).then((response) => {
-        expect(response.headers['x-cer-middleware']).to.eq('active')
-      })
-    })
-
-    it('middleware runs before API route handlers (header present on /api/posts)', () => {
-      cy.request('/api/posts').then((response) => {
-        expect(response.status).to.eq(200)
-        expect(response.headers['x-cer-middleware']).to.eq('active')
-      })
-    })
-  })
-}

package/e2e/cypress/e2e/session-rotation.cy.ts

@@ -1,25 +0,0 @@
-/**
- * P1-3: Session secret rotation.
- *
- * Tests that useSession() supports multiple secrets for key rotation:
- * - New sessions are signed with the first (active) secret.
- * - Old sessions signed with a secondary secret are still readable.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-if (mode === 'ssr') {
-  describe('Session secret rotation (P1-3)', () => {
-    it('writes and reads back a session when sessionSecret is an array', () => {
-      // The kitchen-sink /session-rotation-test page sets a session and reads it back
-      cy.visit('/session-rotation-test')
-      cy.get('[data-cy=session-read]', { timeout: 5000 }).should('contain', 'rotation-user')
-    })
-
-    it('session is stored as an httpOnly cookie', () => {
-      cy.visit('/session-rotation-test')
-      // After visiting the page that sets a session, the cookie should be present
-      cy.getCookie('session').should('exist')
-    })
-  })
-}

package/e2e/cypress/e2e/session.cy.ts

@@ -1,73 +0,0 @@
-/**
- * useSession() e2e tests — verifies that HMAC-signed cookie sessions
- * round-trip correctly across requests via the /api/session endpoint.
- *
- * The kitchen-sink exposes:
- *   GET    /api/session  → { userId: string | null }
- *   POST   /api/session  → creates session with userId = 'test-user'
- *   DELETE /api/session  → clears the session
- *
- * Sessions require a server-side signing key, so these tests only run in
- * SSR mode where the session secret is available.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-if (mode === 'ssr') {
-  describe('useSession() — session create / read / clear (SSR)', () => {
-    beforeEach(() => {
-      cy.clearCookies()
-    })
-
-    it('GET /api/session returns null userId when no session cookie is set', () => {
-      cy.request('/api/session').then((response) => {
-        expect(response.status).to.eq(200)
-        expect(response.body.userId).to.be.null
-      })
-    })
-
-    it('POST /api/session creates a session cookie', () => {
-      cy.request({ method: 'POST', url: '/api/session' }).then((response) => {
-        expect(response.status).to.eq(200)
-        expect(response.body.ok).to.be.true
-      })
-      // Cookie should now be present
-      cy.getCookie('session').should('exist')
-    })
-
-    it('GET /api/session returns userId after session is created', () => {
-      // Create session
-      cy.request({ method: 'POST', url: '/api/session' })
-      // Read session — Cypress automatically forwards the cookie
-      cy.request('/api/session').then((response) => {
-        expect(response.body.userId).to.eq('test-user')
-      })
-    })
-
-    it('DELETE /api/session clears the session', () => {
-      // Create then clear
-      cy.request({ method: 'POST', url: '/api/session' })
-      cy.request({ method: 'DELETE', url: '/api/session' })
-      // Reading again should return null
-      cy.request('/api/session').then((response) => {
-        expect(response.body.userId).to.be.null
-      })
-    })
-
-    it('session persists across multiple requests in the same Cypress session', () => {
-      cy.request({ method: 'POST', url: '/api/session' })
-      // Make several read requests — all should see the same userId
-      cy.request('/api/session').its('body.userId').should('eq', 'test-user')
-      cy.request('/api/session').its('body.userId').should('eq', 'test-user')
-    })
-
-    it('tampered session cookie causes GET to return null userId', () => {
-      cy.request({ method: 'POST', url: '/api/session' })
-      // Overwrite the cookie with garbage
-      cy.setCookie('session', 'tampered.invalidsig')
-      cy.request('/api/session').then((response) => {
-        expect(response.body.userId).to.be.null
-      })
-    })
-  })
-}

package/e2e/cypress/e2e/ssr-render-error.cy.ts

@@ -1,68 +0,0 @@
-/**
- * E2E tests for SSR render error resilience (P0-1).
- *
- * When a page component throws during the SSR render pass, the custom-elements
- * runtime catches the error internally (logs a warning, emits an empty DSD
- * placeholder) and continues rendering — so the server returns 200 with a valid
- * HTML document. The entry-server-template's try/catch protects against
- * *infrastructure-level* errors that escape the runtime's own protection (e.g.
- * a catastrophic failure in the SSR helpers themselves).
- *
- * Observable behaviour for a component-level throw:
- * - HTTP 200 (runtime handles it gracefully)
- * - Valid HTML body with the page skeleton
- * - Server remains operational for subsequent requests
- *
- * Only meaningful in SSR mode where the server renders pages on-request.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-if (mode === 'ssr') {
-  describe('SSR render error resilience — P0-1', () => {
-    it('returns HTTP 200 when a page component throws during render (runtime handles gracefully)', () => {
-      cy.request({ url: '/render-error-test', failOnStatusCode: false }).then((response) => {
-        expect(response.status).to.eq(200)
-      })
-    })
-
-    it('returns a non-empty HTML body even when a component throws', () => {
-      cy.request({ url: '/render-error-test', failOnStatusCode: false }).then((response) => {
-        expect(response.body).to.be.a('string')
-        expect(response.body.length).to.be.greaterThan(0)
-        expect(response.body).to.include('<!DOCTYPE html>')
-      })
-    })
-
-    it('serves a Content-Type: text/html header', () => {
-      cy.request({ url: '/render-error-test', failOnStatusCode: false }).then((response) => {
-        expect(response.headers['content-type']).to.include('text/html')
-      })
-    })
-
-    it('the broken component renders as an empty DSD placeholder (graceful degradation)', () => {
-      cy.request({ url: '/render-error-test', failOnStatusCode: false }).then((response) => {
-        // The runtime emits <page-render-error-test><template shadowrootmode="open"></template>...
-        // or the component tag is present with an empty shadow root.
-        expect(response.body).to.include('page-render-error-test')
-      })
-    })
-
-    it('server responds normally to other routes after a component render error', () => {
-      // First hit the broken route.
-      cy.request({ url: '/render-error-test', failOnStatusCode: false })
-      // Verify the server hasn't crashed and can still serve other routes.
-      cy.request('/about').then((response) => {
-        expect(response.status).to.eq(200)
-      })
-    })
-
-    it('does not leave the server hanging after a component render error', () => {
-      // If the server hung, cy.request() would time out (30s default).
-      // A response (any status) within timeout confirms no hang.
-      cy.request({ url: '/render-error-test', failOnStatusCode: false }).then((response) => {
-        expect(response.status).to.be.a('number')
-      })
-    })
-  })
-}

package/e2e/cypress/e2e/synthetic-404.cy.ts

@@ -1,45 +0,0 @@
-/**
- * P1-1: Synthetic 404 catch-all fallback.
- *
- * When no user-defined catch-all page exists the framework injects a synthetic
- * /:all* route that returns `default: null`. The server must return HTTP 404
- * (not 500) and render the global error component if defined.
- */
-
-const mode = Cypress.env('mode') as 'spa' | 'ssr' | 'ssg'
-
-describe('Synthetic 404 fallback (P1-1)', () => {
-  context('visiting a completely unknown route', () => {
-    it('navigating client-side to an unknown route does not crash the app', () => {
-      cy.visit('/')
-      cy.window().then((win) => {
-        // @ts-expect-error cerRouter is a private global
-        win.__cerRouter?.push('/this-route-does-not-exist-at-all')
-      })
-      // Page should still be functional — no JS error thrown
-      cy.get('body').should('exist')
-    })
-  })
-
-  if (mode === 'ssr') {
-    context('SSR — unknown route returns 404', () => {
-      it('returns HTTP 404 for an unknown path', () => {
-        cy.request({
-          url: '/completely-unknown-route-xyz',
-          failOnStatusCode: false,
-        }).then((response) => {
-          expect(response.status).to.eq(404)
-        })
-      })
-
-      it('does not return 500 for an unknown path', () => {
-        cy.request({
-          url: '/another-unknown-path-abc',
-          failOnStatusCode: false,
-        }).then((response) => {
-          expect(response.status).to.not.eq(500)
-        })
-      })
-    })
-  }
-})