✨ Allow getters to be reconfigured

README.md

@@ -410,3 +410,28 @@ import { config } from 'vuex-module-decorators'
 // Set rawError to true by default on all @Action decorators
 config.rawError = true
 ```
+
+## Stubbing for tests
+
+Actions and mutations can be stubbed like any other function using - for example - [`sinon`](https://sinonjs.org/).
+
+By default, getters are readonly, and cannot be reconfigured, which prevents stubbing.
+
+To override this behaviour in a test environment, set the `configurableGetters` flag:
+
+```typescript
+import { Module, VuexModule, Mutation } from 'vuex-module-decorators'
+
+@Module({
+  name: 'MyModule',
+  configurableGetters: true,
+})
+export default class MyStoreModule extends VuexModule {
+  public test: string = 'initial'
+
+  @Mutation
+  public setTest(val: string) {
+    this.test = val
+  }
+}
+```

dist/types/moduleoptions.d.ts

@@ -15,6 +15,10 @@ export interface StaticModuleOptions {
      * Whether to generate a plain state object, or a state factory for the module
      */
     stateFactory?: boolean;
+    /**
+     * Allow getters to have their property definitions redefined. Useful for stubbing in tests.
+     */
+    configurableGetters?: boolean;
 }
 export interface DynamicModuleOptions {
     /**
@@ -41,5 +45,9 @@ export interface DynamicModuleOptions {
      * Whether to generate a plain state object, or a state factory for the module
      */
     stateFactory?: boolean;
+    /**
+     * Allow getters to have their property definitions redefined. Useful for stubbing in tests.
+     */
+    configurableGetters?: boolean;
 }
 export declare type ModuleOptions = StaticModuleOptions | DynamicModuleOptions;

src/module/staticGenerators.ts

@@ -32,19 +32,13 @@ export function staticGetterGenerator<S>(
   statics: any
 ) {
   Object.keys(module.getters as GetterTree<S, any>).forEach((key) => {
-    if (module.namespaced) {
-      Object.defineProperty(statics, key, {
-        get() {
-          return statics.store.getters[`${modOpt.name}/${key}`]
-        }
-      })
-    } else {
-      Object.defineProperty(statics, key, {
-        get() {
-          return statics.store.getters[key]
-        }
-      })
-    }
+    const moduleKey = module.namespaced ? `${modOpt.name}/${key}` : key
+    Object.defineProperty(statics, key, {
+      configurable: !!modOpt.configurableGetters,
+      get() {
+        return statics.store.getters[moduleKey]
+      }
+    })
   })
 }
 

src/moduleoptions.ts

@@ -15,6 +15,10 @@ export interface StaticModuleOptions {
    * Whether to generate a plain state object, or a state factory for the module
    */
   stateFactory?: boolean
+  /**
+   * Allow getters to have their property definitions redefined. Useful for stubbing in tests.
+   */
+  configurableGetters?: boolean
 }
 
 export interface DynamicModuleOptions {
@@ -47,6 +51,11 @@ export interface DynamicModuleOptions {
    * Whether to generate a plain state object, or a state factory for the module
    */
   stateFactory?: boolean
+
+  /**
+   * Allow getters to have their property definitions redefined. Useful for stubbing in tests.
+   */
+  configurableGetters?: boolean
 }
 
 export type ModuleOptions = StaticModuleOptions | DynamicModuleOptions

test/getmodule/getmodule_getter.ts

@@ -34,4 +34,10 @@ describe('using getters on getModule()', () => {
     expect(getModule(MyNamespacedModule).value).to.equal(10)
     expect(getModule(MyNamespacedModule).twofold).to.equal(20)
   })
+
+  it('cannot reconfigure the getters', function () {
+    expect(() => {
+      Object.defineProperty(getModule(MyModule), 'twofold', {value: 'foo'})
+    }).to.throw(TypeError, 'Cannot redefine property')
+  })
 })

test/getmodule/getmodule_getter_configurable.ts

@@ -0,0 +1,49 @@
+import Vuex from 'vuex'
+import Vue from 'vue'
+Vue.use(Vuex)
+import { getModule, Module, VuexModule } from '../..'
+import { expect } from 'chai'
+
+const store = new Vuex.Store({})
+
+@Module({ name: 'mm', store, dynamic: true, configurableGetters: true })
+class DynamicModule extends VuexModule {
+  public value = 10
+
+  public get twofold(): number {
+    return this.value * 2
+  }
+}
+
+@Module({name: 'mm', store, configurableGetters: true})
+class StaticModule extends VuexModule {
+  public value = 10
+
+  public get twofold(): number {
+    return this.value * 2
+  }
+}
+
+describe('using getters on dynamic getModule()', () => {
+  it('getter should return adjusted value', function() {
+    expect(getModule(DynamicModule).value).to.equal(10)
+    expect(getModule(DynamicModule).twofold).to.equal(20)
+  })
+
+  it('can reconfigure the getters', function () {
+    Object.defineProperty(getModule(DynamicModule), 'twofold', {value: 'foo'})
+    expect(getModule(DynamicModule).twofold).to.equal('foo');
+  })
+})
+
+describe('using getters on static getModule()', () => {
+  it('getter should return adjusted value', function () {
+    expect(getModule(StaticModule).value).to.equal(10)
+    expect(getModule(StaticModule).twofold).to.equal(20)
+  })
+
+  it('can reconfigure the getters', function () {
+    Object.defineProperty(getModule(StaticModule), 'twofold', {value: 'foo'})
+    expect(getModule(StaticModule).twofold).to.equal('foo');
+  })
+})