fix: Collapsed should support All and none

docs/user_guide.rst

@@ -248,15 +248,18 @@ Auto Collapsing Table Rows
 
 By default, all rows in the **Results** table will be expanded except those that have :code:`Passed`.
 
-This behavior can be customized either with a query parameter: :code:`?collapsed=Passed,XFailed,Skipped`
-or by setting the :code:`render_collapsed` in a configuration file (pytest.ini, setup.cfg, etc).
+This behavior can be customized with a query parameter: :code:`?collapsed=Passed,XFailed,Skipped`.
+If you want all rows to be collapsed you can pass :code:`?collapsed=All`.
+By setting the query parameter to empty string :code:`?collapsed=""` **none** of the rows will be collapsed.
+
+Note that the query parameter is case insensitive, so passing :code:`PASSED` and :code:`passed` has the same effect.
+
+You can also set the collapsed behaviour by setting the :code:`render_collapsed` in a configuration file (pytest.ini, setup.cfg, etc).
 
 .. code-block:: ini
 
   [pytest]
-  render_collapsed = True
-
-**NOTE:** Setting :code:`render_collapsed` will, unlike the query parameter, affect all statuses.
+  render_collapsed = FIX THIS
 
 Controlling Test Result Visibility Via Query Params
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

src/pytest_html/scripts/datamanager.js

@@ -2,7 +2,7 @@ const { getCollapsedCategory } = require('./storage.js')
 
 class DataManager {
     setManager(data) {
-        const collapsedCategories = [...getCollapsedCategory(), 'passed']
+        const collapsedCategories = [...getCollapsedCategory()]
         const dataBlob = { ...data, tests: Object.values(data.tests).flat().map((test, index) => ({
             ...test,
             id: `test_${index}`,

src/pytest_html/scripts/main.js

@@ -3,7 +3,7 @@ const { dom, findAll } = require('./dom.js')
 const { manager } = require('./datamanager.js')
 const { doSort } = require('./sort.js')
 const { doFilter } = require('./filter.js')
-const { getVisible } = require('./storage.js')
+const { getVisible, possibleResults } = require('./storage.js')
 
 const removeChildren = (node) => {
     while (node.firstChild) {
@@ -61,16 +61,6 @@ const renderContent = (tests) => {
 }
 
 const renderDerived = (tests, collectedItems, isFinished) => {
-    const possibleResults = [
-        { result: 'passed', label: 'Passed' },
-        { result: 'skipped', label: 'Skipped' },
-        { result: 'failed', label: 'Failed' },
-        { result: 'error', label: 'Errors' },
-        { result: 'xfailed', label: 'Unexpected failures' },
-        { result: 'xpassed', label: 'Unexpected passes' },
-        { result: 'rerun', label: 'Reruns' },
-    ]
-
     const currentFilter = getVisible()
     possibleResults.forEach(({ result, label }) => {
         const count = tests.filter((test) => test.result.toLowerCase() === result).length

src/pytest_html/scripts/storage.js

@@ -1,4 +1,13 @@
-const possibleFilters = ['passed', 'skipped', 'failed', 'error', 'xfailed', 'xpassed', 'rerun']
+const possibleResults = [
+    { result: 'passed', label: 'Passed' },
+    { result: 'skipped', label: 'Skipped' },
+    { result: 'failed', label: 'Failed' },
+    { result: 'error', label: 'Errors' },
+    { result: 'xfailed', label: 'Unexpected failures' },
+    { result: 'xpassed', label: 'Unexpected passes' },
+    { result: 'rerun', label: 'Reruns' },
+]
+const possibleFilters = possibleResults.map((item) => item.result)
 
 const getVisible = () => {
     const url = new URL(window.location.href)
@@ -50,15 +59,28 @@ const setSort = (type) => {
 }
 
 const getCollapsedCategory = () => {
-    let categotries
+    let categories
     if (typeof window !== 'undefined') {
         const url = new URL(window.location.href)
         const collapsedItems = new URLSearchParams(url.search).get('collapsed')
-        categotries = collapsedItems?.split(',') || []
+        switch (true) {
+            case collapsedItems === null:
+                categories = ['passed'];
+                break;
+            case collapsedItems?.length === 0 || /^["']{2}$/.test(collapsedItems):
+                categories = [];
+                break;
+            case /^all$/.test(collapsedItems):
+                categories = [...possibleFilters];
+                break;
+            default:
+                categories = collapsedItems?.split(',').map(item => item.toLowerCase()) || [];
+                break;
+        }
     } else {
-        categotries = []
+        categories = []
     }
-    return categotries
+    return categories
 }
 
 const getSortDirection = () => JSON.parse(sessionStorage.getItem('sortAsc'))
@@ -75,4 +97,6 @@ module.exports = {
     setSort,
     setSortDirection,
     getCollapsedCategory,
+    possibleFilters,
+    possibleResults,
 }

testing/unittest.js

@@ -156,3 +156,57 @@ describe('utils tests', () => {
         })
     })
 })
+
+describe('Storage tests', () => {
+    describe('getCollapsedCategory', () => {
+        let originalWindow
+        const mockWindow = (queryParam) => {
+            const mock = {
+                location: {
+                    href: `https://example.com/page?${queryParam}`
+                }
+            }
+            originalWindow = global.window
+            global.window = mock
+        }
+        after(() => global.window = originalWindow)
+
+        it('collapses passed by default', () => {
+            mockWindow('')
+            const collapsedItems = storageModule.getCollapsedCategory()
+            expect(collapsedItems).to.eql(['passed'])
+        })
+
+        it('collapses specified outcomes', () => {
+            mockWindow('collapsed=failed,error')
+            const collapsedItems = storageModule.getCollapsedCategory()
+            expect(collapsedItems).to.eql(['failed', 'error'])
+        })
+
+        it('collapses all', () => {
+            mockWindow('collapsed=all')
+            const collapsedItems = storageModule.getCollapsedCategory()
+            expect(collapsedItems).to.eql(storageModule.possibleFilters)
+        })
+
+        it('handles case insensitive params', () => {
+            mockWindow('collapsed=fAiLeD,ERROR,passed')
+            const collapsedItems = storageModule.getCollapsedCategory()
+            expect(collapsedItems).to.eql(['failed', 'error', 'passed'])
+        })
+
+        const falsy = [
+          { param: 'collapsed' },
+          { param: 'collapsed=' },
+          { param: 'collapsed=""' },
+          { param: 'collapsed=\'\'' }
+        ]
+        falsy.forEach(({param}) => {
+            it(`collapses none with ${param}`, () => {
+                mockWindow(param)
+                const collapsedItems = storageModule.getCollapsedCategory()
+                expect(collapsedItems).to.be.empty
+            })
+        })
+    })
+})