test: updated tests for DisabledVault

Author: jaissica12

test/src/tests-identity.ts

@@ -650,20 +650,20 @@ describe('identity', function() {
         });
 
         describe('#createIdentityCache', function() {
-            it('should use LocalStorageVault when noFunctional is false by default', async () => {
+            it('should save id cache to local storage when noFunctional is false by default', async () => {
                 mParticle.init(apiKey, window.mParticle.config);
                 await waitForCondition(hasIdentifyReturned);
                 expect(localStorage.getItem('mprtcl-v4_abcdef-id-cache')).to.be.ok;
             });
 
-            it('should use DisabledVault when noFunctional is true', async () => {
+            it('should NOT save id cache to local storage when noFunctional is true', async () => {
                 mParticle.config.noFunctional = true;
                 mParticle.init(apiKey, window.mParticle.config);
                 await waitForCondition(hasIdentifyReturned);
                 expect(localStorage.getItem('mprtcl-v4_abcdef-id-cache')).not.to.be.ok;
             });
 
-            it('should use LocalStorageVault when noFunctional is false', async () => {
+            it('should save id cache to local storage when noFunctional is false', async () => {
                 mParticle.config.noFunctional = false;
                 mParticle.init(apiKey, window.mParticle.config);
                 await waitForCondition(hasIdentifyReturned);

test/src/vault.spec.ts

@@ -428,75 +428,52 @@ describe('Vault', () => {
         describe('#store', () => {
             it('should NOT write to localStorage', () => {
                 const storageKey = 'test-disabled-store-empty';
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
 
-                vault.store(testObject);
+                vault.store('testString');
 
                 expect(vault.contents).to.equal(null);
                 expect(window.localStorage.getItem(storageKey)).to.equal(null);
             });
 
             it('should NOT overwrite existing localStorage value and keep contents null', () => {
                 const storageKey = 'test-disabled-store-existing';
-                window.localStorage.setItem(
-                    storageKey,
-                    JSON.stringify(testObject),
-                );
+                window.localStorage.setItem(storageKey, 'existingItem');
 
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
 
-                vault.store({ pinky: { narf: 'poit' } });
+                vault.store('newValue');
 
                 expect(vault.contents).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal(
-                    JSON.stringify(testObject),
-                );
+                expect(window.localStorage.getItem(storageKey)).to.equal('existingItem');
             });
         });
 
         describe('#retrieve', () => {
             it('should return null when nothing is stored', () => {
                 const storageKey = 'test-disabled-retrieve-empty';
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
                 const retrievedItem = vault.retrieve();
                 expect(retrievedItem).to.equal(null);
             });
 
             it('should return null even if localStorage has a value', () => {
                 const storageKey = 'test-disabled-retrieve-existing';
-                window.localStorage.setItem(
-                    storageKey,
-                    JSON.stringify(testObject),
-                );
+                window.localStorage.setItem(storageKey, 'existingItem');
 
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
                 const retrievedItem = vault.retrieve();
                 expect(retrievedItem).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal(
-                    JSON.stringify(testObject),
-                );
+                expect(window.localStorage.getItem(storageKey)).to.equal('existingItem');
             });
         });
 
         describe('#purge', () => {
             it('should keep contents null when purging', () => {
                 const storageKey = 'test-disabled-purge-existing';
-                window.localStorage.setItem(
-                    storageKey,
-                    JSON.stringify(testObject),
-                );
+                window.localStorage.setItem(storageKey, 'existing');
 
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
 
                 vault.purge();
 
@@ -506,12 +483,9 @@ describe('Vault', () => {
 
             it('should keep contents null when purging an empty key', () => {
                 const storageKey = 'test-disabled-purge-empty';
-                const vault = new DisabledVault<Dictionary<Dictionary<string>>>(
-                    storageKey,
-                );
+                const vault = new DisabledVault<string>(storageKey);
 
                 vault.purge();
-                console.log(window.localStorage.getItem(storageKey));
                 expect(vault.contents).to.equal(null);
                 expect(window.localStorage.getItem(storageKey)).to.equal(null);
             });