From 7f841a66a409a70fa10a4ff268fc672445555ddc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rouven=20Bu=CC=88hlmann?= <rouven.buehlmann@dreipol.ch>
Date: Fri, 24 Aug 2018 13:11:53 +0200
Subject: [PATCH 1/4] Change modal name

---
 src/components/overlay/overlay.vue | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/components/overlay/overlay.vue b/src/components/overlay/overlay.vue
index b2005d9..b935a10 100644
--- a/src/components/overlay/overlay.vue
+++ b/src/components/overlay/overlay.vue
@@ -8,15 +8,15 @@
             <div class="overlay--root" v-if="overlay.isOpen" :key="overlay.timestamp">
                 <div class="overlay--backdrop"></div>
                 <div class="overlay--display">
-                    <div class="overlay--wrap-outer">
+                    <div class="overlay--wrap-outer" :style="overlayScrollLockStyles">
                         <div class="overlay--wrap-inner">
                             <div class="overlay--backdrop-click-area"
                                     @click.prevent="closeOverlay({ id })"></div>
                             <div class="overlay--container">
                                 <div class="overlay--revealer">
-                                    <cmp-modal :facets="overlay.facets">
+                                    <UiModal :facets="overlay.facets">
                                         <component slot :is="overlay.component" v-bind="overlay.props"/>
-                                    </cmp-modal>
+                                    </UiModal>
                                 </div>
                             </div>
                         </div>
@@ -30,7 +30,7 @@
 <script>
     import { mapActions, mapGetters, mapState } from 'vuex';
     import bemMixin from '../../mixins/bem';
-    import Modal from '../modal/modal.vue';
+    import UiModal from '../modal/modal.vue';
     import scrollLockHelperMixin from '../../mixins/scroll-lock-helper';
 
 
@@ -40,7 +40,7 @@
             scrollLockHelperMixin,
         ],
         components: {
-            'cmp-modal': Modal,
+            UiModal,
         },
         props: {
             id: {
@@ -50,6 +50,7 @@
         },
         data() {
             return {
+                hasDisabledScroll: null,
                 autoCloseTimeout: null,
             };
         },
@@ -68,6 +69,9 @@
             overlay() {
                 return this.overlays[this.id] || {};
             },
+            overlayScrollLockStyles() {
+                return this.hasDisabledScroll ? {} : this.scrollLockStyles;
+            },
         },
         methods: {
             ...mapActions('scroll', ['disableScroll']),
@@ -86,6 +90,7 @@
                 }, autoClose.delay || 0);
             },
             onEnterHook() {
+                this.hasDisabledScroll = this.overlay.disableScroll;
                 this.overlay.disableScroll && this.disableScroll({ isLocked: true });
             },
             onAfterEnterHook() {

From 689c677f7bfb73568aaf6798aea82f0fd0e1c93a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rouven=20Bu=CC=88hlmann?= <rouven.buehlmann@dreipol.ch>
Date: Fri, 24 Aug 2018 15:31:28 +0200
Subject: [PATCH 2/4] Simplify overlay unit tests

---
 src/interfaces/IOverlay.ts         |   2 +-
 src/modules/overlay/getters.js     |  17 +-
 src/modules/overlay/index.js       |   2 -
 src/modules/overlay/module.spec.js | 244 +++++++++++++++++------------
 4 files changed, 157 insertions(+), 108 deletions(-)

diff --git a/src/interfaces/IOverlay.ts b/src/interfaces/IOverlay.ts
index ec0b050..2abaabd 100644
--- a/src/interfaces/IOverlay.ts
+++ b/src/interfaces/IOverlay.ts
@@ -1,6 +1,6 @@
 export interface IOverlay {
     id: string;
-    transition: string;
+    transition?: string;
     isOpen?: boolean;
     facets?: string[];
     disableScroll?: boolean;
diff --git a/src/modules/overlay/getters.js b/src/modules/overlay/getters.js
index 79ee1c5..d3a9efb 100644
--- a/src/modules/overlay/getters.js
+++ b/src/modules/overlay/getters.js
@@ -1,10 +1,22 @@
+/**
+ * Search overlays by a search function
+ * @param {Object[]} overlays - The list of overlays
+ * @param {Function} fn - The search function
+ * @return {boolean} The resulting flag
+ */
+function findInOverlays(overlays, fn) {
+    const values = Object.keys(overlays).map(key => overlays[key]);
+    return !!values.find(fn);
+}
+
 /**
  * Check whether there are any open overlays
  * @param {Object} state - The vuex state object
  * @return {boolean} The resulting flag
  */
 export const hasOpenOverlays = state => {
-    return Object.values(state.overlays).some(({ isOpen }) => isOpen);
+    const fn = ({ isOpen }) => isOpen;
+    return findInOverlays(state.overlays, fn);
 };
 
 /**
@@ -13,5 +25,6 @@ export const hasOpenOverlays = state => {
  * @return {boolean} The resulting flag
  */
 export const hasScrollLockingOverlays = state => {
-    return Object.values(state.overlays).some(({ disableScroll }) => disableScroll);
+    const fn = ({ disableScroll }) => disableScroll;
+    return findInOverlays(state.overlays, fn);
 };
diff --git a/src/modules/overlay/index.js b/src/modules/overlay/index.js
index 52fbc05..74e786b 100644
--- a/src/modules/overlay/index.js
+++ b/src/modules/overlay/index.js
@@ -7,7 +7,6 @@ import { CLOSE_OVERLAY, MOUNT_OVERLAY, OPEN_OVERLAY, PREPARE_CLOSE_OVERLAY, UNMO
 import * as actions from './actions';
 import * as getters from './getters';
 
-
 export const DEFAULT_OPENING_STATE = {
     isOpen: true,
     facets: ['base'],
@@ -80,7 +79,6 @@ const state = {
     overlays: {},
 };
 
-
 export default {
     namespaced: true,
     mutations,
diff --git a/src/modules/overlay/module.spec.js b/src/modules/overlay/module.spec.js
index 945dc69..b67005f 100644
--- a/src/modules/overlay/module.spec.js
+++ b/src/modules/overlay/module.spec.js
@@ -2,29 +2,8 @@ import { expect } from 'chai';
 import { spy } from 'sinon';
 import * as getters from './getters';
 import * as actions from './actions';
-import cloneDeep from 'lodash.clonedeep';
 import { CLOSE_OVERLAY, MOUNT_OVERLAY, OPEN_OVERLAY, PREPARE_CLOSE_OVERLAY, UNMOUNT_OVERLAY } from '../mutation-types';
-import overlayModule, { DEFAULT_OPENING_STATE, DEFAULT_CLOSING_STATE } from './index';
-
-function dummyOverlay(options = {}) {
-    return {
-        ...cloneDeep(DEFAULT_OPENING_STATE),
-        id: `${ Math.random() }`,
-        ...options,
-    };
-}
-
-function generateStateFromOverlaysList(overlays) {
-    return overlays.reduce((state, overlay) => {
-        return {
-            state,
-            overlays: {
-                ...state.overlays,
-                [overlay.id]: overlay,
-            },
-        };
-    }, cloneDeep(overlayModule.state));
-}
+import overlayModule, { DEFAULT_CLOSING_STATE } from './index';
 
 describe('Overlay spec', () => {
     describe('Overlays default export', () => {
@@ -39,52 +18,85 @@ describe('Overlay spec', () => {
 
     describe('Getters', () => {
         describe('hasOpenOverlays', () => {
-            it('No Overlays opened found', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ isOpen: false })]);
+            it('No active overlays count as if there is none open', () => {
+                const state = {
+                    overlays: {},
+                };
 
                 expect(getters.hasOpenOverlays(state)).to.be.equal(false);
             });
 
-            it('No Overlays opened found (empty overlays object)', () => {
-                const state = generateStateFromOverlaysList([]);
+            it('Closed overlays are not taken into account', () => {
+                const state = {
+                    overlays: {
+                        foo: { isOpen: false },
+                    },
+                };
 
                 expect(getters.hasOpenOverlays(state)).to.be.equal(false);
             });
 
-            it('A opened Overlay was found', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ isOpen: false }), dummyOverlay({ isOpen: true })]);
+            it('Open overlays are reported', () => {
+                const state = {
+                    overlays: {
+                        foo: { isOpen: false },
+                        bar: { isOpen: true },
+                    },
+                };
 
                 expect(getters.hasOpenOverlays(state)).to.be.equal(true);
             });
 
-            it('A opened Overlay was found (multiple opened overlays)', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ isOpen: true }), dummyOverlay({ isOpen: false }), dummyOverlay({ isOpen: true })]);
+            it('Multiple open overlays are reported', () => {
+                const state = {
+                    overlays: {
+                        foo: { isOpen: true },
+                        baz: { isOpen: true },
+                        bar: { isOpen: false },
+                    },
+                };
 
                 expect(getters.hasOpenOverlays(state)).to.be.equal(true);
             });
         });
 
         describe('hasScrollLockingOverlays', () => {
-            it('No Overlays disable the page scroll', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ disableScroll: false })]);
+            it('No active overlays count as if there is none disabling page scroll', () => {
+                const state = {
+                    overlays: {},
+                };
 
                 expect(getters.hasScrollLockingOverlays(state)).to.be.equal(false);
             });
 
-            it('No Overlays disable the page scroll (empty overlays object)', () => {
-                const state = generateStateFromOverlaysList([]);
+            it('Overlays that do not disable page scroll are not taken into account', () => {
+                const state = {
+                    overlays: {
+                        foo: { disableScroll: false },
+                    },
+                };
 
                 expect(getters.hasScrollLockingOverlays(state)).to.be.equal(false);
             });
 
-            it('A Overlay disables the page scroll', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ disableScroll: true })]);
+            it('An overlay disabling page scroll is reported', () => {
+                const state = {
+                    overlays: {
+                        foo: { disableScroll: true },
+                    },
+                };
 
                 expect(getters.hasScrollLockingOverlays(state)).to.be.equal(true);
             });
 
-            it('Multiple Overlays disable the page scroll', () => {
-                const state = generateStateFromOverlaysList([dummyOverlay({ disableScroll: true }), dummyOverlay({ disableScroll: false }), dummyOverlay({ disableScroll: true })]);
+            it('Multiple overlays disabling page scroll are reported', () => {
+                const state = {
+                    overlays: {
+                        foo: { disableScroll: true },
+                        baz: { disableScroll: true },
+                        bar: { disableScroll: false },
+                    },
+                };
 
                 expect(getters.hasScrollLockingOverlays(state)).to.be.equal(true);
             });
@@ -92,28 +104,32 @@ describe('Overlay spec', () => {
     });
 
     describe('Actions', () => {
-        describe('OpenOverlay', () => {
-            it('Opening a new overlay dispatches properly all the mutations', async function() {
+        describe('openOverlay', () => {
+            it('Opening a new overlay dispatches all mutations properly', async function() {
                 const commit = spy();
-                const state = generateStateFromOverlaysList([]);
-                const newOverlay = dummyOverlay({ title: 'Hello' });
+                const state = { overlays: {} };
+                const newOverlay = { id: 'foo', props: { title: 'bar' } };
 
                 await actions.openOverlay({ commit, state }, newOverlay);
 
                 const [mountEventArgs, openEventArgs] = commit.args;
                 const [openEventMutationType, openEventOverlayData] = openEventArgs;
 
-                expect(mountEventArgs).to.be.deep.equal([MOUNT_OVERLAY, { id: newOverlay.id }]);
+                expect(mountEventArgs).to.be.deep.equal([MOUNT_OVERLAY, { id: 'foo' }]);
                 expect(openEventMutationType).to.be.equal(OPEN_OVERLAY);
-                expect(openEventOverlayData.title).to.be.equal(newOverlay.title, 'The payload was properly forwarded');
+
+                expect(openEventOverlayData.props.title).to.to.not.be.undefined;
+                expect(openEventOverlayData.props.title).to.be.equal('bar', 'The payload was properly forwarded');
             });
 
-            it('Opening twice the same overlay will not dispatch again the mounting mutation', async function() {
+            it('Opening the same overlay twice will not dispatch the mounting mutation again', async function() {
                 const commit = spy();
-                const overlayID = 'foo';
-                const initialOverlay = dummyOverlay({ title: 'Hello', id: overlayID });
-                const state = generateStateFromOverlaysList([initialOverlay]);
-                const newOverlay = dummyOverlay({ title: 'World', id: overlayID });
+                const newOverlay = { id: 'foo', props: { title: 'baz' } };
+                const state = {
+                    overlays: {
+                        foo: { props: { title: 'bar' } },
+                    },
+                };
 
                 await actions.openOverlay({ commit, state }, newOverlay);
 
@@ -121,58 +137,67 @@ describe('Overlay spec', () => {
 
                 expect(commit.args).to.have.length(1);
                 expect(openEventMutationType).to.be.equal(OPEN_OVERLAY);
-                expect(openEventOverlayData.title).to.be.equal(newOverlay.title, 'The payload was properly forwarded');
+                expect(openEventOverlayData.props.title).to.to.not.be.undefined;
+                expect(openEventOverlayData.props.title).to.be.equal('baz', 'The payload was properly forwarded');
             });
         });
 
         describe('closeOverlay', () => {
-            it('Closing an overlay dispatches properly all the mutations', async function() {
+            it('Closing an overlay properly dispatches all mutations', async function() {
                 const commit = spy();
-                const initialOverlay = dummyOverlay({ title: 'Hello' });
-                const state = generateStateFromOverlaysList([initialOverlay]);
+                const state = {
+                    overlays: {
+                        foo: { props: { title: 'bar' } },
+                    },
+                };
 
-                await actions.closeOverlay({ commit, state }, { id: initialOverlay.id });
+                await actions.closeOverlay({ commit, state }, { id: 'foo' });
 
                 const [prepareCloseEvent, closeOverlaysEvent] = commit.args;
                 const [prepareCloseMutationType, prepareCloseData] = prepareCloseEvent;
                 const [closeEventMutationType, closeEventData] = closeOverlaysEvent;
 
                 expect(prepareCloseMutationType).to.be.equal(PREPARE_CLOSE_OVERLAY);
-                expect(prepareCloseData.id).to.be.equal(initialOverlay.id);
+                expect(prepareCloseData.id).to.be.equal('foo');
 
                 expect(closeEventMutationType).to.be.equal(CLOSE_OVERLAY);
-                expect(closeEventData.id).to.be.equal(initialOverlay.id);
+                expect(closeEventData.id).to.be.equal('foo');
             });
 
             it('Closing an overlay allows to asynchronously dispatch the unmount event', async function() {
                 const commit = spy();
-                const initialOverlay = dummyOverlay({ title: 'Hello' });
-                const state = generateStateFromOverlaysList([initialOverlay]);
+                const state = {
+                    overlays: {
+                        foo: { id: 'foo', props: { title: 'bar' } },
+                    },
+                };
 
-                await actions.closeOverlay({ commit, state }, { id: initialOverlay.id });
+                await actions.closeOverlay({ commit, state }, { id: 'foo' });
 
                 const [, closeOverlaysEvent] = commit.args;
                 const [, closeEventData] = closeOverlaysEvent;
 
-                // this can be called by vue components at any time
+                // This can be called by vue components at any time
                 closeEventData.onAfterClose();
 
                 const [, , unmountOverlayEvent] = commit.args;
                 const [unmountEventMutationType, umountEventData] = unmountOverlayEvent;
 
                 expect(unmountEventMutationType).to.be.equal(UNMOUNT_OVERLAY);
-                expect(umountEventData.id).to.be.equal(initialOverlay.id);
+                expect(umountEventData.id).to.be.equal('foo');
             });
 
-            it('Closing an overlay allows also custom transitions', async function() {
+            it('Closing an overlay allows for custom transitions', async function() {
                 const commit = spy();
-                const initialOverlay = dummyOverlay({ title: 'Hello' });
-                const state = generateStateFromOverlaysList([initialOverlay]);
-                const customTransitionName = 'my-cool-transition';
+                const state = {
+                    overlays: {
+                        foo: { id: 'foo', props: { title: 'bar' } },
+                    },
+                };
 
                 await actions.closeOverlay({ commit, state }, {
-                    id: initialOverlay.id,
-                    transition: customTransitionName,
+                    id: 'foo',
+                    transition: 'my-cool-transition',
                 });
 
                 const [, closeOverlaysEvent] = commit.args;
@@ -180,12 +205,12 @@ describe('Overlay spec', () => {
 
                 closeEventData.onAfterClose();
 
-                expect(closeEventData.transition).to.be.equal(customTransitionName);
+                expect(closeEventData.transition).to.be.equal('my-cool-transition');
             });
 
             it('Closing unknown overlays will not dispatch any event', async function() {
                 const commit = spy();
-                const state = generateStateFromOverlaysList([]);
+                const state = { overlays: {} };
 
                 await actions.closeOverlay({ commit, state }, { id: 'unknown' });
 
@@ -196,66 +221,79 @@ describe('Overlay spec', () => {
 
     describe('Mutations', () => {
         it('Mount overlay', () => {
-            const state = generateStateFromOverlaysList([]);
-            const id = 'foo';
+            const state = { overlays: {} };
 
-            overlayModule.mutations[MOUNT_OVERLAY](state, { id });
+            overlayModule.mutations[MOUNT_OVERLAY](state, { id: 'foo' });
 
-            expect(state.overlays[id]).to.be.deep.equal(DEFAULT_CLOSING_STATE);
+            expect(state.overlays['foo']).to.be.deep.equal(DEFAULT_CLOSING_STATE);
         });
 
         it('Unmount overlay', () => {
-            const overlayToRemove = dummyOverlay();
-            const state = generateStateFromOverlaysList([overlayToRemove]);
+            const state = {
+                overlays: {
+                    foo: {},
+                },
+            };
 
-            overlayModule.mutations[UNMOUNT_OVERLAY](state, { id: overlayToRemove.id });
+            overlayModule.mutations[UNMOUNT_OVERLAY](state, { id: 'foo' });
 
             expect(state.overlays).to.be.deep.equal({});
         });
 
         it('Open overlay', () => {
-            const overlayToOpen = dummyOverlay();
-            const state = generateStateFromOverlaysList([overlayToOpen]);
-            const overlayTitle = 'Hello';
-
-            overlayModule.mutations[OPEN_OVERLAY](state, { id: overlayToOpen.id, title: overlayTitle });
+            const state = {
+                overlays: {},
+            };
 
+            overlayModule.mutations[OPEN_OVERLAY](state, { id: 'foo', props: { title: 'bar' } });
 
-            expect(state.overlays[overlayToOpen.id].isOpen).to.be.equal(true);
-            expect(state.overlays[overlayToOpen.id].disableScroll).to.be.equal(true);
-            expect(state.overlays[overlayToOpen.id].title).to.be.equal(overlayTitle);
+            expect(state.overlays.foo.isOpen).to.be.equal(true);
+            expect(state.overlays.foo.disableScroll).to.be.equal(true);
+            expect(state.overlays.foo.props.title).to.be.equal('bar');
         });
 
         it('Prepare closing overlay', () => {
-            const overlayToClose = dummyOverlay();
-            const state = generateStateFromOverlaysList([overlayToClose]);
-            const customTransitionName = 'my-cool-transition';
-
-            overlayModule.mutations[PREPARE_CLOSE_OVERLAY](state, { id: overlayToClose.id, transition: customTransitionName });
+            const state = {
+                overlays: {
+                    foo: { isOpen: true },
+                },
+            };
+
+            overlayModule.mutations[PREPARE_CLOSE_OVERLAY](state, {
+                id: 'foo',
+                transition: 'my-cool-transition',
+            });
 
-            expect(state.overlays[overlayToClose.id].isOpen).to.be.equal(true);
-            expect(state.overlays[overlayToClose.id].disableScroll).to.be.equal(false);
-            expect(state.overlays[overlayToClose.id].transition).to.be.equal(customTransitionName);
+            expect(state.overlays.foo.isOpen).to.be.equal(true);
+            expect(state.overlays.foo.disableScroll).to.be.equal(false);
+            expect(state.overlays.foo.transition).to.be.equal('my-cool-transition');
         });
 
-        it('Prepare closing unknown overlay', () => {
-            const overlayToClose = dummyOverlay();
-            const state = generateStateFromOverlaysList([]);
-            const customTransitionName = 'my-cool-transition';
+        it('Prepare closing unknown overlays', () => {
+            const state = {
+                overlays: {
+                    foo: {},
+                },
+            };
 
-            overlayModule.mutations[PREPARE_CLOSE_OVERLAY](state, { id: overlayToClose.id, transition: customTransitionName });
+            overlayModule.mutations[PREPARE_CLOSE_OVERLAY](state, {
+                id: 'unknown',
+            });
 
-            expect(state.overlays).to.be.deep.equal({});
+            expect(state.overlays).to.be.deep.equal({ foo: {} });
         });
 
         it('Close overlay', () => {
-            const overlayToClose = dummyOverlay();
-            const state = generateStateFromOverlaysList([overlayToClose]);
+            const state = {
+                overlays: {
+                    foo: { isOpen: true, disableScroll: true },
+                },
+            };
 
-            overlayModule.mutations[CLOSE_OVERLAY](state, { id: overlayToClose.id });
+            overlayModule.mutations[CLOSE_OVERLAY](state, { id: 'foo' });
 
-            expect(state.overlays[overlayToClose.id].isOpen).to.be.equal(false);
-            expect(state.overlays[overlayToClose.id].disableScroll).to.be.equal(false);
+            expect(state.overlays.foo.isOpen).to.be.equal(false);
+            expect(state.overlays.foo.disableScroll).to.be.equal(false);
         });
     });
 });

From 7d367475630777180afa91a96657c05ff1dad61e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rouven=20Bu=CC=88hlmann?= <rouven.buehlmann@dreipol.ch>
Date: Fri, 24 Aug 2018 15:34:00 +0200
Subject: [PATCH 3/4] Minor improvement

---
 src/modules/overlay/module.spec.js | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/modules/overlay/module.spec.js b/src/modules/overlay/module.spec.js
index b67005f..bbb8e80 100644
--- a/src/modules/overlay/module.spec.js
+++ b/src/modules/overlay/module.spec.js
@@ -108,9 +108,8 @@ describe('Overlay spec', () => {
             it('Opening a new overlay dispatches all mutations properly', async function() {
                 const commit = spy();
                 const state = { overlays: {} };
-                const newOverlay = { id: 'foo', props: { title: 'bar' } };
 
-                await actions.openOverlay({ commit, state }, newOverlay);
+                await actions.openOverlay({ commit, state }, { id: 'foo', props: { title: 'bar' } });
 
                 const [mountEventArgs, openEventArgs] = commit.args;
                 const [openEventMutationType, openEventOverlayData] = openEventArgs;
@@ -124,14 +123,13 @@ describe('Overlay spec', () => {
 
             it('Opening the same overlay twice will not dispatch the mounting mutation again', async function() {
                 const commit = spy();
-                const newOverlay = { id: 'foo', props: { title: 'baz' } };
                 const state = {
                     overlays: {
                         foo: { props: { title: 'bar' } },
                     },
                 };
 
-                await actions.openOverlay({ commit, state }, newOverlay);
+                await actions.openOverlay({ commit, state }, { id: 'foo', props: { title: 'baz' } });
 
                 const [openEventMutationType, openEventOverlayData] = commit.args[0];
 
@@ -195,10 +193,7 @@ describe('Overlay spec', () => {
                     },
                 };
 
-                await actions.closeOverlay({ commit, state }, {
-                    id: 'foo',
-                    transition: 'my-cool-transition',
-                });
+                await actions.closeOverlay({ commit, state }, { id: 'foo', transition: 'my-cool-transition' });
 
                 const [, closeOverlaysEvent] = commit.args;
                 const [, closeEventData] = closeOverlaysEvent;

From 5497d26e9053961a7a705ccd6d17a9d75490db26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rouven=20Bu=CC=88hlmann?= <rouven.buehlmann@dreipol.ch>
Date: Wed, 5 Sep 2018 12:03:26 +0200
Subject: [PATCH 4/4] Fix merge fail

---
 src/modules/overlay/module.spec.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/modules/overlay/module.spec.js b/src/modules/overlay/module.spec.js
index e8c228b..61f0a25 100644
--- a/src/modules/overlay/module.spec.js
+++ b/src/modules/overlay/module.spec.js
@@ -136,7 +136,6 @@ describe('Overlay spec', () => {
                 expect(commit.args).to.have.length(1);
                 expect(openOverlayEventMutationType).to.be.equal(OPEN_OVERLAY);
                 expect(openOverlayEventData.props.title).to.to.not.be.undefined;
-                expect(openOverlayEventData.props.props.title).to.to.not.be.undefined;
                 expect(openOverlayEventData.props.title).to.be.equal('baz', 'The payload was properly forwarded');
             });
         });