diff --git a/src/layout/css/style.scss b/src/layout/css/style.scss
index c0d4d224..5fa7be7f 100644
--- a/src/layout/css/style.scss
+++ b/src/layout/css/style.scss
@@ -183,23 +183,31 @@ div.media {
   flex: 0 0 25px;
   align-items: center;
 }
-
 .collapsed {
   display: none;
 }
 
-.expander::after {
-  content: ' (show details)';
+@mixin rowToggle {
   color: #bbb;
   font-style: italic;
   cursor: pointer;
 }
 
-.collapser::after {
-  content: ' (hide details)';
-  color: #bbb;
-  font-style: italic;
+.col-result {
   cursor: pointer;
+  &:hover::after {
+    @include rowToggle;
+  }
+}
+.col-result.collapser {
+  &:hover::after {
+    content: ' (hide details)';
+  }
+}
+.col-result.expander {
+  &:hover::after {
+    content: ' (show details)';
+  }
 }
 
 /*------------------
diff --git a/src/pytest_html/nextgen.py b/src/pytest_html/nextgen.py
index 9eba6f8b..278c58c1 100644
--- a/src/pytest_html/nextgen.py
+++ b/src/pytest_html/nextgen.py
@@ -123,13 +123,17 @@ def _data_content(self, *args, **kwargs):
     def _media_content(self, *args, **kwargs):
         pass
 
-    def _process_extras(self, report):
-        test_id = report.nodeid.encode("utf-8").decode("unicode_escape")
+    def _process_extras(self, report, test_id):
         test_index = hasattr(report, "rerun") and report.rerun + 1 or 0
         report_extras = getattr(report, "extras", [])
         for extra_index, extra in enumerate(report_extras):
             content = extra["content"]
-            asset_name = self._asset_filename(test_id, extra_index, test_index, extra['extension'])
+            asset_name = self._asset_filename(
+                test_id.encode("utf-8").decode("unicode_escape"),
+                extra_index,
+                test_index,
+                extra['extension']
+            )
             if extra["format_type"] == extras.FORMAT_JSON:
                 content = json.dumps(content)
                 extra["content"] = self._data_content(content, asset_name=asset_name, mime_type=extra["mime_type"])
@@ -216,6 +220,11 @@ def pytest_runtest_logreport(self, report):
             config=self._config, report=report
         )
 
+        test_id = report.nodeid
+        if report.when != "call":
+            test_id += f"::{report.when}"
+            data["nodeid"] = test_id
+
         if report.longrepr:
             data["longreprtext"] = report.longreprtext
 
@@ -229,7 +238,7 @@ def pytest_runtest_logreport(self, report):
         self._config.hook.pytest_html_results_table_html(report=report, data=table_html)
         data.update({"tableHtml": table_html})
 
-        data.update({"extras": self._process_extras(report)})
+        data.update({"extras": self._process_extras(report, test_id)})
         self._report.data["tests"].append(data)
         self._generate_report()
 
diff --git a/src/pytest_html/resources/index.jinja2 b/src/pytest_html/resources/index.jinja2
index 0d3b9e74..90a6b210 100644
--- a/src/pytest_html/resources/index.jinja2
+++ b/src/pytest_html/resources/index.jinja2
@@ -76,6 +76,14 @@
         <th colspan="4">No results found. Try to check the filters</th>
       </tr>
     </template>
+    <template id="template_table-colgroup">
+      <colgroup>
+        <col span="1" style="width: 25%;">
+        <col span="1" style="width: 25%;">
+        <col span="1" style="width: 25%;">
+        <col span="1" style="width: 25%;">
+      </colgroup>
+    </template>
     <!-- END TEMPLATES -->
     <div class="summary">
       <div class="summary__data">
@@ -113,6 +121,7 @@
     {% for p in postfix %}
     {{ p|safe }}
     {% endfor %}
+
     <table id="results-table"></table>
   </body>
   <footer>
diff --git a/src/pytest_html/resources/style.css b/src/pytest_html/resources/style.css
index 93bd1ead..20fe0a18 100644
--- a/src/pytest_html/resources/style.css
+++ b/src/pytest_html/resources/style.css
@@ -168,18 +168,21 @@ div.media {
   display: none;
 }
 
-.expander::after {
-  content: " (show details)";
+.col-result {
+  cursor: pointer;
+}
+.col-result:hover::after {
   color: #bbb;
   font-style: italic;
   cursor: pointer;
 }
 
-.collapser::after {
+.col-result.collapser:hover::after {
   content: " (hide details)";
-  color: #bbb;
-  font-style: italic;
-  cursor: pointer;
+}
+
+.col-result.expander:hover::after {
+  content: " (show details)";
 }
 
 /*------------------
diff --git a/src/pytest_html/scripts/datamanager.js b/src/pytest_html/scripts/datamanager.js
index 42c7f71f..7d6e7cef 100644
--- a/src/pytest_html/scripts/datamanager.js
+++ b/src/pytest_html/scripts/datamanager.js
@@ -1,7 +1,12 @@
 class DataManager {
     setManager(data) {
-        this.data = { ...data }
-        this.renderData = { ...data }
+        const dataBlob = { ...data, tests: data.tests.map((test, index) => ({
+            ...test,
+            id: `test_${index}`,
+            collapsed: false,
+        })) }
+        this.data = { ...dataBlob }
+        this.renderData = { ...dataBlob }
     }
     get allData() {
         return { ...this.data }
@@ -10,11 +15,15 @@ class DataManager {
         this.renderData = { ...this.data }
     }
     setRender(data) {
-        this.renderData.tests = data
+        this.renderData.tests = [...data]
+    }
+    toggleCollapsedItem(id) {
+        this.renderData.tests = this.renderData.tests.map((test) =>
+            test.id === id ? { ...test, collapsed: !test.collapsed } : test,
+        )
     }
-
     set allCollapsed(collapsed) {
-        this.renderData = { ...this.data, tests: [...this.data.tests.map((test) => (
+        this.renderData = { ...this.renderData, tests: [...this.renderData.tests.map((test) => (
             { ...test, collapsed }
         ))] }
     }
diff --git a/src/pytest_html/scripts/dom.js b/src/pytest_html/scripts/dom.js
index 145878cc..12b5f5a0 100644
--- a/src/pytest_html/scripts/dom.js
+++ b/src/pytest_html/scripts/dom.js
@@ -1,6 +1,8 @@
+const storageModule = require('./storage.js')
 const { formatDuration } = require('./utils.js')
 const mediaViewer = require('./mediaViewer.js')
 const templateEnvRow = document.querySelector('#template_environment_row')
+const templateCollGroup = document.querySelector('#template_table-colgroup')
 const templateResult = document.querySelector('#template_results-table__tbody')
 const aTag = document.querySelector('#template_a')
 const listHeader = document.querySelector('#template_results-table__head')
@@ -48,8 +50,8 @@ const dom = {
     },
     getListHeader: ({ resultsTableHeader }) => {
         const header = listHeader.content.cloneNode(true)
-        const sortAttr = localStorage.getItem('sort')
-        const sortAsc = JSON.parse(localStorage.getItem('sortAsc'))
+        const sortAttr = storageModule.getSort()
+        const sortAsc = JSON.parse(storageModule.getSortDirection())
         const sortables = ['outcome', 'nodeid', 'duration']
 
         sortables.forEach((sortCol) => {
@@ -64,11 +66,14 @@ const dom = {
         return header
     },
     getListHeaderEmpty: () => listHeaderEmpty.content.cloneNode(true),
-    getResultTBody: ({ nodeid, longreprtext, duration, extras, resultsTableRow, tableHtml, outcome, collapsed }) => {
+    getColGroup: () => templateCollGroup.content.cloneNode(true),
+    getResultTBody: ({ nodeid, id, longreprtext, duration, extras, resultsTableRow, tableHtml, outcome, collapsed }) => {
         const outcomeLower = outcome.toLowerCase()
         const resultBody = templateResult.content.cloneNode(true)
         resultBody.querySelector('tbody').classList.add(outcomeLower)
         resultBody.querySelector('.col-result').innerText = outcome
+        resultBody.querySelector('.col-result').classList.add(`${collapsed ? 'expander' : 'collapser'}`)
+        resultBody.querySelector('.col-result').dataset.id = id
         resultBody.querySelector('.col-name').innerText = nodeid
         resultBody.querySelector('.col-duration').innerText = `${formatDuration(duration)}s`
 
@@ -95,7 +100,7 @@ const dom = {
             }
 
             if (format_type === 'html') {
-              resultBody.querySelector('.extraHTML').insertAdjacentHTML('beforeend', `<div>${content}</div>`)
+                resultBody.querySelector('.extraHTML').insertAdjacentHTML('beforeend', `<div>${content}</div>`)
             }
         })
         mediaViewer.setUp(resultBody, media)
diff --git a/src/pytest_html/scripts/filter.js b/src/pytest_html/scripts/filter.js
index 52ad0208..bfb994eb 100644
--- a/src/pytest_html/scripts/filter.js
+++ b/src/pytest_html/scripts/filter.js
@@ -1,28 +1,27 @@
 const { manager } = require('./datamanager.js')
-const localStorageModule = require('./localstorage_utils.js')
+const storageModule = require('./storage.js')
 
 const getFilteredSubSet = (filter) =>
-    manager.allData.tests.filter(({ outcome }) => !filter.includes(outcome))
+    manager.allData.tests.filter(({ outcome }) => !filter.includes(outcome.toLowerCase()))
 
 const doInitFilter = () => {
-    const currentFilter = localStorageModule.getFilter()
+    const currentFilter = storageModule.getFilter()
     const filteredSubset = getFilteredSubSet(currentFilter)
     manager.setRender(filteredSubset)
 }
 
 const doFilter = (type, apply) => {
-    const currentFilter = localStorageModule.getFilter()
+    const currentFilter = storageModule.getFilter()
     if (!apply) {
         currentFilter.push(type)
     } else {
-        const index = currentFilter.indexOf(type);
+        const index = currentFilter.indexOf(type)
         if (index > -1) {
             currentFilter.splice(index, 1)
         }
     }
 
-    localStorageModule.setFilter(currentFilter)
-
+    storageModule.setFilter(currentFilter)
     if (currentFilter.length) {
         const filteredSubset = getFilteredSubSet(currentFilter)
         manager.setRender(filteredSubset)
diff --git a/src/pytest_html/scripts/index.js b/src/pytest_html/scripts/index.js
index e49ce8b3..7fcab5fe 100644
--- a/src/pytest_html/scripts/index.js
+++ b/src/pytest_html/scripts/index.js
@@ -1,4 +1,4 @@
-const { redraw } = require('./main.js')
+const { redraw, bindEvents } = require('./main.js')
 const { doInitFilter } = require('./filter.js')
 const { doInitSort } = require('./sort.js')
 const { manager } = require('./datamanager.js')
@@ -9,6 +9,7 @@ function init() {
     doInitFilter()
     doInitSort()
     redraw()
+    bindEvents()
 }
 
 init()
diff --git a/src/pytest_html/scripts/localstorage_utils.js b/src/pytest_html/scripts/localstorage_utils.js
deleted file mode 100644
index 25424294..00000000
--- a/src/pytest_html/scripts/localstorage_utils.js
+++ /dev/null
@@ -1,22 +0,0 @@
-const getFilter = () => [...new Set(JSON.parse(localStorage.getItem('filter')))]
-const setFilter = (currentFilter) => {
-    localStorage.setItem('filter', JSON.stringify(currentFilter))
-}
-
-const getSort = () => localStorage.getItem('sort')
-const setSort = (type) => localStorage.setItem('sort', type)
-
-const getSortDirection = () => JSON.parse(localStorage.getItem('sortAsc'))
-
-const setSortDirection = (ascending) => {
-    localStorage.setItem('sortAsc', ascending)
-}
-
-module.exports = {
-    getFilter,
-    setFilter,
-    getSort,
-    getSortDirection,
-    setSort,
-    setSortDirection,
-}
diff --git a/src/pytest_html/scripts/main.js b/src/pytest_html/scripts/main.js
index 009e4416..23898611 100644
--- a/src/pytest_html/scripts/main.js
+++ b/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 { getFilter } = require('./localstorage_utils.js')
+const { getFilter } = require('./storage.js')
 
 const removeChildren = (node) => {
     while (node.firstChild) {
@@ -37,7 +37,7 @@ const renderContent = (tests) => {
     if (!rows.length) {
         tableHeader.appendChild(dom.getListHeaderEmpty())
     }
-
+    table.appendChild(dom.getColGroup())
     table.appendChild(tableHeader)
 
     rows.forEach((row) => !!row && table.appendChild(row))
@@ -45,6 +45,20 @@ const renderContent = (tests) => {
     table.querySelectorAll('.extra').forEach((item) => {
         item.colSpan = document.querySelectorAll('th').length
     })
+    findAll('.sortable').forEach((elem) => {
+        elem.addEventListener('click', (evt) => {
+            const { target: element } = evt
+            const { columnType } = element.dataset
+            doSort(columnType)
+            redraw()
+        })
+    })
+    findAll('.col-result').forEach((elem) => {
+        elem.addEventListener('click', ({ target }) => {
+            manager.toggleCollapsedItem(target.dataset.id)
+            redraw()
+        })
+    })
 }
 
 const renderDerived = (tests, collectedItems, isFinished) => {
@@ -86,23 +100,16 @@ const renderDerived = (tests, collectedItems, isFinished) => {
 }
 
 const bindEvents = () => {
-    findAll('.sortable').forEach((elem) => {
-        elem.addEventListener('click', (evt) => {
-            const { target: element } = evt
-            const { columnType } = element.dataset
+    const filterColumn = (evt) => {
+        const { target: element } = evt
+        const { testResult } = element.dataset
 
-            doSort(columnType)
-            redraw()
-        })
-    })
+        doFilter(testResult, element.checked)
+        redraw()
+    }
     findAll('input[name="filter_checkbox"]').forEach((elem) => {
-        elem.addEventListener('click', (evt) => {
-            const { target: element } = evt
-            const { testResult } = element.dataset
-
-            doFilter(testResult, element.checked)
-            redraw()
-        })
+        elem.removeEventListener('click', filterColumn)
+        elem.addEventListener('click', filterColumn)
     })
     document.querySelector('#show_all_details').addEventListener('click', () => {
         manager.allCollapsed = false
@@ -114,7 +121,7 @@ const bindEvents = () => {
     })
 }
 
-const renderPage = () => {
+const redraw = () => {
     const { testSubset, allTests, collectedItems, isFinished } = manager
 
     renderStatic()
@@ -122,11 +129,5 @@ const renderPage = () => {
     renderDerived(allTests, collectedItems, isFinished)
 }
 
-const redraw = () => {
-    setTimeout(() => {
-        renderPage()
-        bindEvents()
-    }, 0)
-}
-
 exports.redraw = redraw
+exports.bindEvents = bindEvents
diff --git a/src/pytest_html/scripts/sort.js b/src/pytest_html/scripts/sort.js
index 1711ea2e..aee74719 100644
--- a/src/pytest_html/scripts/sort.js
+++ b/src/pytest_html/scripts/sort.js
@@ -1,5 +1,5 @@
 const { manager } = require('./datamanager.js')
-const localStorageModule = require('./localstorage_utils.js')
+const storageModule = require('./storage.js')
 
 const genericSort = (list, key, ascending) => {
     const sorted = list.sort((a, b) => a[key] === b[key] ? 0 : a[key] > b[key] ? 1 : -1)
@@ -11,19 +11,19 @@ const genericSort = (list, key, ascending) => {
 }
 
 const doInitSort = () => {
-    const type = localStorageModule.getSort()
-    const ascending = localStorageModule.getSortDirection()
+    const type = storageModule.getSort()
+    const ascending = storageModule.getSortDirection()
     const list = manager.testSubset
     const sortedList = genericSort(list, type, ascending)
     manager.setRender(sortedList)
 }
 
 const doSort = (type) => {
-    const newSortType = localStorageModule.getSort() !== type
-    const currentAsc = localStorageModule.getSortDirection()
+    const newSortType = storageModule.getSort() !== type
+    const currentAsc = storageModule.getSortDirection()
     const ascending = newSortType ? true : !currentAsc
-    localStorageModule.setSort(type)
-    localStorageModule.setSortDirection(ascending)
+    storageModule.setSort(type)
+    storageModule.setSortDirection(ascending)
     const list = manager.testSubset
 
     const sortedList = genericSort(list, type, ascending)
diff --git a/src/pytest_html/scripts/storage.js b/src/pytest_html/scripts/storage.js
new file mode 100644
index 00000000..794806e3
--- /dev/null
+++ b/src/pytest_html/scripts/storage.js
@@ -0,0 +1,22 @@
+const getFilter = () => [...new Set(JSON.parse(sessionStorage.getItem('filter')))]
+const setFilter = (currentFilter) => {
+    sessionStorage.setItem('filter', JSON.stringify(currentFilter))
+}
+
+const getSort = () => sessionStorage.getItem('sort')
+const setSort = (type) => sessionStorage.setItem('sort', type)
+
+const getSortDirection = () => JSON.parse(sessionStorage.getItem('sortAsc'))
+
+const setSortDirection = (ascending) => {
+    sessionStorage.setItem('sortAsc', ascending)
+}
+
+module.exports = {
+    getFilter,
+    setFilter,
+    getSort,
+    getSortDirection,
+    setSort,
+    setSortDirection,
+}
diff --git a/testing/unittest.js b/testing/unittest.js
index 530a6c24..0429fdb8 100644
--- a/testing/unittest.js
+++ b/testing/unittest.js
@@ -3,75 +3,83 @@ const sinon = require('sinon')
 const { doInitFilter, doFilter } = require('../src/pytest_html/scripts/filter.js')
 const { doInitSort, doSort } = require('../src/pytest_html/scripts/sort.js')
 const dataModule = require('../src/pytest_html/scripts/datamanager.js')
-const localStorageModule = require('../src/pytest_html/scripts/localstorage_utils.js')
-
+const storageModule = require('../src/pytest_html/scripts/storage.js')
 
 
 describe('Filter tests', () => {
-    let getFilterMock, managerSpy
+    let getFilterMock
+    let managerSpy
     before(() => {
         const jsonDatan = {
-            "tests": 
+            'tests':
                 [
                     {
-                        "outcome": "passed",
+                        'id': 'passed_1',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "failed",
+                        'id': 'failed_2',
+                        'outcome': 'failed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'passed_3',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'passed_4',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'passed_5',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
-                    }
-                ]
+                        'id': 'passed_6',
+                        'outcome': 'passed',
+                    },
+                ],
         }
         dataModule.manager.setManager(jsonDatan)
     })
-    afterEach(() => [getFilterMock, managerSpy].forEach( fn => fn.restore()))
-    after(() => dataModule.manager.setManager({}))
+    afterEach(() => [getFilterMock, managerSpy].forEach((fn) => fn.restore()))
+    after(() => dataModule.manager.setManager({ tests: [] }))
     describe('doInitFilter', () => {
-
-
-        it("has no stored filters", () => {
-            getFilterMock = sinon.stub(localStorageModule, 'getFilter').returns([])
+        it('has no stored filters', () => {
+            getFilterMock = sinon.stub(storageModule, 'getFilter').returns([])
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doInitFilter()
             expect(managerSpy.callCount).to.eql(1)
-            expect(dataModule.manager.testSubset.map(({outcome}) => outcome)).to.eql([ 'passed', 'failed', 'passed', 'passed', 'passed', 'passed' ])
+            expect(dataModule.manager.testSubset.map(({ outcome }) => outcome)).to.eql([
+                'passed', 'failed', 'passed', 'passed', 'passed', 'passed',
+            ])
         })
-        it("exclude passed", () => {
-            getFilterMock = sinon.stub(localStorageModule, 'getFilter').returns(['passed'])
+        it('exclude passed', () => {
+            getFilterMock = sinon.stub(storageModule, 'getFilter').returns(['passed'])
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doInitFilter()
             expect(managerSpy.callCount).to.eql(1)
-            expect(dataModule.manager.testSubset.map(({outcome}) => outcome)).to.eql([ 'failed' ])
+            expect(dataModule.manager.testSubset.map(({ outcome }) => outcome)).to.eql(['failed'])
         })
     })
     describe('doFilter', () => {
-        var setFilterMock
+        let setFilterMock
         afterEach(() => setFilterMock.restore())
-        it("removes a filter", () => {
-            getFilterMock = sinon.stub(localStorageModule, 'getFilter').returns(['passed'])
-            setFilterMock = sinon.stub(localStorageModule, 'setFilter')
+        it('removes a filter', () => {
+            getFilterMock = sinon.stub(storageModule, 'getFilter').returns(['passed'])
+            setFilterMock = sinon.stub(storageModule, 'setFilter')
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doFilter('passed', true)
             expect(managerSpy.callCount).to.eql(0)
-            expect(dataModule.manager.testSubset.map(({outcome}) => outcome)).to.eql([ 'passed', 'failed', 'passed', 'passed', 'passed', 'passed' ])
+            expect(dataModule.manager.testSubset.map(({ outcome }) => outcome)).to.eql([
+                'passed', 'failed', 'passed', 'passed', 'passed', 'passed'
+            ])
         })
-        it("applies a filter", () => {
-            getFilterMock = sinon.stub(localStorageModule, 'getFilter').returns([])
-            setFilterMock = sinon.stub(localStorageModule, 'setFilter')
+        it('applies a filter', () => {
+            getFilterMock = sinon.stub(storageModule, 'getFilter').returns([])
+            setFilterMock = sinon.stub(storageModule, 'setFilter')
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doFilter('passed', false)
@@ -85,64 +93,76 @@ describe('Filter tests', () => {
 describe('Sort tests', () => {
     before(() => {
         const jsonDatan = {
-            "tests": 
+            'tests': 
                 [
                     {
-                        "outcome": "passed",
+                        'id': 'outcome_1',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "failed",
+                        'id': 'outcome_2',
+                        'outcome': 'failed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'outcome_3',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'outcome_4',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
+                        'id': 'outcome_5',
+                        'outcome': 'passed',
                     },
                     {
-                        "outcome": "passed",
-                    }
-                ]
+                        'id': 'outcome_6',
+                        'outcome': 'passed',
+                    },
+                ],
         }
         dataModule.manager.setManager(jsonDatan)
     })
-    after(() => dataModule.manager.setManager({}))
-    describe('doInitSort', () =>  {
-        let managerSpy, sortMock, sortDirectionMock
+    after(() => dataModule.manager.setManager({ tests: [] }))
+    describe('doInitSort', () => {
+        let managerSpy
+        let sortMock
+        let sortDirectionMock
         beforeEach(() => dataModule.manager.resetRender())
 
-        afterEach(() => [sortMock,sortDirectionMock,managerSpy].forEach(fn => fn.restore()))
-        it("has no stored sort", () => {
-            sortMock = sinon.stub(localStorageModule, 'getSort').returns(null)
-            sortDirectionMock = sinon.stub(localStorageModule, 'getSortDirection').returns(null)
+        afterEach(() => [sortMock,sortDirectionMock, managerSpy].forEach((fn) => fn.restore()))
+        it('has no stored sort', () => {
+            sortMock = sinon.stub(storageModule, 'getSort').returns(null)
+            sortDirectionMock = sinon.stub(storageModule, 'getSortDirection').returns(null)
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doInitSort()
             expect(managerSpy.callCount).to.eql(1)
-            expect(dataModule.manager.testSubset.map(({outcome}) => outcome)).to.eql([ 'passed', 'failed', 'passed', 'passed', 'passed', 'passed' ])
+            expect(dataModule.manager.testSubset.map(({ outcome }) => outcome)).to.eql([
+                'passed', 'failed', 'passed', 'passed', 'passed', 'passed',
+            ])
         })
-        it("has stored sort preference", () => {
-            sortMock = sinon.stub(localStorageModule, 'getSort').returns('outcome')
-            sortDirectionMock = sinon.stub(localStorageModule, 'getSortDirection').returns(false)
+        it('has stored sort preference', () => {
+            sortMock = sinon.stub(storageModule, 'getSort').returns('outcome')
+            sortDirectionMock = sinon.stub(storageModule, 'getSortDirection').returns(false)
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doInitSort()
             expect(managerSpy.callCount).to.eql(1)
-            expect(dataModule.manager.testSubset.map(({outcome}) => outcome)).to.eql([ 'failed', 'passed', 'passed', 'passed', 'passed', 'passed' ])
+            expect(dataModule.manager.testSubset.map(({ outcome }) => outcome)).to.eql([
+                'failed', 'passed', 'passed', 'passed', 'passed', 'passed',
+            ])
         })
     })
     describe('doSort', () => {
         let getSortMock, setSortMock, getSortDirectionMock, setSortDirection, managerSpy
 
         afterEach(() => [getSortMock, setSortMock, getSortDirectionMock, setSortDirection, managerSpy].forEach(fn => fn.restore()))
-        it("sort on outcome", () => {
-            getSortMock = sinon.stub(localStorageModule, 'getSort').returns(null)
-            setSortMock = sinon.stub(localStorageModule, 'setSort')
-            getSortDirectionMock = sinon.stub(localStorageModule, 'getSortDirection').returns(null)
-            setSortDirection = sinon.stub(localStorageModule, 'setSortDirection')
+        it('sort on outcome', () => {
+            getSortMock = sinon.stub(storageModule, 'getSort').returns(null)
+            setSortMock = sinon.stub(storageModule, 'setSort')
+            getSortDirectionMock = sinon.stub(storageModule, 'getSortDirection').returns(null)
+            setSortDirection = sinon.stub(storageModule, 'setSortDirection')
             managerSpy = sinon.spy(dataModule.manager, 'setRender')
 
             doSort('outcome')